depau/libfprint
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

cleanup: Use FPI prefix for all the internal enum types

Browse source
This commit is contained in:
Marco Trevisan (Treviño) 2019-12-16 22:45:00 +01:00
parent 2158c5e2d1
commit c8e1269f61
20 changed files with 264 additions and 266 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
doc/libfprint-sections.txt
View file

@ -129,7 +129,7 @@ fpi_get_driver_types
<FILE>fpi-device</FILE> <FILE>fpi-device</FILE>
FpDeviceClass FpDeviceClass
FpTimeoutFunc FpTimeoutFunc
FpDeviceAction FpiDeviceAction
FpIdEntry FpIdEntry
fpi_device_get_usb_device fpi_device_get_usb_device
fpi_device_get_virtual_env fpi_device_get_virtual_env
@ -173,7 +173,7 @@ fpi_image_resize
<SECTION> <SECTION>
<FILE>fpi-image-device</FILE> <FILE>fpi-image-device</FILE>
<TITLE>FpImageDevice</TITLE> <TITLE>FpImageDevice</TITLE>
FpImageDeviceState FpiImageDeviceState
FpImageDeviceClass FpImageDeviceClass
fpi_image_device_session_error fpi_image_device_session_error
fpi_image_device_open_complete fpi_image_device_open_complete
@ -197,7 +197,7 @@ BUG
<SECTION> <SECTION>
<FILE>fpi-print</FILE> <FILE>fpi-print</FILE>
FpPrintType FpiPrintType
FpiMatchResult FpiMatchResult
fpi_print_add_print fpi_print_add_print
fpi_print_set_type fpi_print_set_type

4
doc/libfprint-sections.txt-new-manual
View file

@ -90,7 +90,7 @@ fp_image_get_width
<TITLE>Base class for image devices</TITLE> <TITLE>Base class for image devices</TITLE>
FpImageDevice FpImageDevice
FpImageDeviceClass FpImageDeviceClass
FpImageDeviceState FpiImageDeviceState
</SECTION> </SECTION>
<SECTION> <SECTION>
@ -114,5 +114,3 @@ FpUsbTransferCallback
FP_USB_ENDPOINT_IN FP_USB_ENDPOINT_IN
FP_USB_ENDPOINT_OUT FP_USB_ENDPOINT_OUT
</SECTION> </SECTION>

40
libfprint/drivers/elan.c
View file

@ -74,8 +74,8 @@ struct _FpiDeviceElan
/* state */ /* state */
gboolean deactivating; gboolean deactivating;
FpImageDeviceState dev_state; FpiImageDeviceState dev_state;
FpImageDeviceState dev_state_next; FpiImageDeviceState dev_state_next;
unsigned char *last_read; unsigned char *last_read;
unsigned char calib_atts_left; unsigned char calib_atts_left;
unsigned char calib_status; unsigned char calib_status;
@ -481,7 +481,7 @@ stop_capture_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
/* The device is inactive at this point. */ /* 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) if (self->deactivating)
{ {
@ -538,7 +538,7 @@ capture_run_state (FpiSsm *ssm, FpDevice *dev)
break; break;
case CAPTURE_READ_DATA: case CAPTURE_READ_DATA:
self->dev_state = FP_IMAGE_DEVICE_STATE_CAPTURE; self->dev_state = FPI_IMAGE_DEVICE_STATE_CAPTURE;
/* 0x55 - finger present /* 0x55 - finger present
* 0xff - device not calibrated (probably) */ * 0xff - device not calibrated (probably) */
@ -773,7 +773,7 @@ calibrate_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
if (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); fpi_image_device_session_error (FP_IMAGE_DEVICE (dev), error);
} }
else else
@ -951,7 +951,7 @@ elan_change_state (FpImageDevice *idev)
{ {
FpDevice *dev = FP_DEVICE (idev); FpDevice *dev = FP_DEVICE (idev);
FpiDeviceElan *self = FPI_DEVICE_ELAN (dev); 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) if (self->dev_state == next_state)
{ {
@ -965,18 +965,18 @@ elan_change_state (FpImageDevice *idev)
switch (next_state) 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 */ /* 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); elan_calibrate (dev);
break; break;
case FP_IMAGE_DEVICE_STATE_CAPTURE: case FPI_IMAGE_DEVICE_STATE_CAPTURE:
/* not used */ /* not used */
break; break;
case FP_IMAGE_DEVICE_STATE_INACTIVE: case FPI_IMAGE_DEVICE_STATE_INACTIVE:
case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF: case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
elan_stop_capture (dev); elan_stop_capture (dev);
break; break;
} }
@ -991,7 +991,7 @@ elan_change_state_async (FpDevice *dev,
} }
static void static void
dev_change_state (FpImageDevice *dev, FpImageDeviceState state) dev_change_state (FpImageDevice *dev, FpiImageDeviceState state)
{ {
FpiDeviceElan *self = FPI_DEVICE_ELAN (dev); FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
GSource *timeout; GSource *timeout;
@ -999,17 +999,17 @@ dev_change_state (FpImageDevice *dev, FpImageDeviceState state)
G_DEBUG_HERE (); G_DEBUG_HERE ();
/* Inactive and await finger off are equivalent for the elan driver. */ /* Inactive and await finger off are equivalent for the elan driver. */
if (state == FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF) if (state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
state = FP_IMAGE_DEVICE_STATE_INACTIVE; state = FPI_IMAGE_DEVICE_STATE_INACTIVE;
if (self->dev_state_next == state) if (self->dev_state_next == state)
fp_dbg ("change to state %d already queued", state); fp_dbg ("change to state %d already queued", state);
switch (state) switch (state)
{ {
case FP_IMAGE_DEVICE_STATE_INACTIVE: case FPI_IMAGE_DEVICE_STATE_INACTIVE:
case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON: case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF: { case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF: {
char *name; char *name;
/* schedule state change instead of calling it directly to allow all actions /* schedule state change instead of calling it directly to allow all actions
@ -1026,7 +1026,7 @@ dev_change_state (FpImageDevice *dev, FpImageDeviceState state)
break; 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 */ /* TODO MAYBE: split capture ssm into smaller ssms and use this state */
self->dev_state = state; self->dev_state = state;
self->dev_state_next = state; self->dev_state_next = state;
@ -1044,7 +1044,7 @@ dev_deactivate (FpImageDevice *dev)
G_DEBUG_HERE (); 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. */ /* The device is inactive already, complete the operation immediately. */
fpi_image_device_deactivate_complete (dev, NULL); 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 * need to signal back deactivation) and then ensure we will change
* to the inactive state eventually. */ * to the inactive state eventually. */
self->deactivating = TRUE; self->deactivating = TRUE;
dev_change_state (dev, FP_IMAGE_DEVICE_STATE_INACTIVE); dev_change_state (dev, FPI_IMAGE_DEVICE_STATE_INACTIVE);
} }
} }

2
libfprint/drivers/elan.h
View file

@ -222,4 +222,4 @@ static void elan_calibrate (FpDevice *dev);
static void elan_capture (FpDevice *dev); static void elan_capture (FpDevice *dev);
static void dev_change_state (FpImageDevice *dev, static void dev_change_state (FpImageDevice *dev,
FpImageDeviceState state); FpiImageDeviceState state);

4
libfprint/drivers/synaptics/synaptics.c
View file

@ -517,7 +517,7 @@ list_msg_cb (FpiDeviceSynaptics *self,
get_enroll_templates_resp->templates[n].finger_id, get_enroll_templates_resp->templates[n].finger_id,
uid); uid);
fpi_print_set_type (print, FP_PRINT_RAW); fpi_print_set_type (print, FPI_PRINT_RAW);
fpi_print_set_device_stored (print, TRUE); fpi_print_set_device_stored (print, TRUE);
g_object_set (print, "fp-data", data, NULL); g_object_set (print, "fp-data", data, NULL);
g_object_set (print, "description", get_enroll_templates_resp->templates[n].user_id, NULL); g_object_set (print, "description", get_enroll_templates_resp->templates[n].user_id, NULL);
@ -856,7 +856,7 @@ enroll (FpDevice *device)
finger, finger,
uid); uid);
fpi_print_set_type (print, FP_PRINT_RAW); fpi_print_set_type (print, FPI_PRINT_RAW);
fpi_print_set_device_stored (print, TRUE); fpi_print_set_device_stored (print, TRUE);
g_object_set (print, "fp-data", data, NULL); g_object_set (print, "fp-data", data, NULL);
g_object_set (print, "description", user_id, NULL); g_object_set (print, "description", user_id, NULL);

24
libfprint/drivers/uru4000.c
View file

@ -122,7 +122,7 @@ struct _FpiDeviceUru4000
const struct uru4k_dev_profile *profile; const struct uru4k_dev_profile *profile;
uint8_t interface; uint8_t interface;
FpImageDeviceState activate_state; FpiImageDeviceState activate_state;
unsigned char last_reg_rd[16]; unsigned char last_reg_rd[16];
unsigned char last_hwstat; unsigned char last_hwstat;
@ -408,16 +408,16 @@ change_state_write_reg_cb (FpiUsbTransfer *transfer,
} }
static void static void
dev_change_state (FpImageDevice *dev, FpImageDeviceState state) dev_change_state (FpImageDevice *dev, FpiImageDeviceState state)
{ {
FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (dev); FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (dev);
switch (state) switch (state)
{ {
case FP_IMAGE_DEVICE_STATE_INACTIVE: case FPI_IMAGE_DEVICE_STATE_INACTIVE:
case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON: case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF: case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
case FP_IMAGE_DEVICE_STATE_CAPTURE: case FPI_IMAGE_DEVICE_STATE_CAPTURE:
break; break;
default: default:
@ -773,7 +773,7 @@ imaging_run_state (FpiSsm *ssm, FpDevice *_dev)
fpimg->flags |= FPI_IMAGE_V_FLIPPED | FPI_IMAGE_H_FLIPPED; fpimg->flags |= FPI_IMAGE_V_FLIPPED | FPI_IMAGE_H_FLIPPED;
fpi_image_device_image_captured (dev, fpimg); 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); fpi_ssm_jump_to_state (ssm, IMAGING_CAPTURE);
else else
fpi_ssm_mark_completed (ssm); fpi_ssm_mark_completed (ssm);
@ -1176,7 +1176,7 @@ deactivate_write_reg_cb (FpiUsbTransfer *transfer, FpDevice *dev,
static void static void
dev_deactivate (FpImageDevice *dev) dev_deactivate (FpImageDevice *dev)
{ {
dev_change_state (dev, FP_IMAGE_DEVICE_STATE_INACTIVE); dev_change_state (dev, FPI_IMAGE_DEVICE_STATE_INACTIVE);
} }
static void static void
@ -1187,7 +1187,7 @@ execute_state_change (FpImageDevice *dev)
switch (self->activate_state) switch (self->activate_state)
{ {
case FP_IMAGE_DEVICE_STATE_INACTIVE: case FPI_IMAGE_DEVICE_STATE_INACTIVE:
fp_dbg ("deactivating"); fp_dbg ("deactivating");
self->irq_cb = NULL; self->irq_cb = NULL;
self->irq_cb_data = NULL; self->irq_cb_data = NULL;
@ -1195,7 +1195,7 @@ execute_state_change (FpImageDevice *dev)
deactivate_write_reg_cb, NULL); deactivate_write_reg_cb, NULL);
break; break;
case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON: case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
fp_dbg ("wait finger on"); fp_dbg ("wait finger on");
if (!IRQ_HANDLER_IS_RUNNING (self)) if (!IRQ_HANDLER_IS_RUNNING (self))
{ {
@ -1209,7 +1209,7 @@ execute_state_change (FpImageDevice *dev)
change_state_write_reg_cb, NULL); change_state_write_reg_cb, NULL);
break; break;
case FP_IMAGE_DEVICE_STATE_CAPTURE: case FPI_IMAGE_DEVICE_STATE_CAPTURE:
fp_dbg ("starting capture"); fp_dbg ("starting capture");
self->irq_cb = NULL; self->irq_cb = NULL;
@ -1229,7 +1229,7 @@ execute_state_change (FpImageDevice *dev)
change_state_write_reg_cb, NULL); change_state_write_reg_cb, NULL);
break; break;
case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF: case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
fp_dbg ("await finger off"); fp_dbg ("await finger off");
if (!IRQ_HANDLER_IS_RUNNING (self)) if (!IRQ_HANDLER_IS_RUNNING (self))
{ {

2
libfprint/fp-device-private.h
View file

@ -41,7 +41,7 @@ typedef struct
GSList *sources; GSList *sources;
/* We always make sure that only one task is run at a time. */ /* We always make sure that only one task is run at a time. */
FpDeviceAction current_action; FpiDeviceAction current_action;
GTask *current_task; GTask *current_task;
GAsyncReadyCallback current_user_cb; GAsyncReadyCallback current_user_cb;
gulong current_cancellable_id; gulong current_cancellable_id;

26
libfprint/fp-device.c
View file

@ -81,7 +81,7 @@ fp_device_cancel_in_idle_cb (gpointer user_data)
FpDevicePrivate *priv = fp_device_get_instance_private (self); FpDevicePrivate *priv = fp_device_get_instance_private (self);
g_assert (cls->cancel); 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!"); g_debug ("Idle cancelling on ongoing operation!");
@ -148,7 +148,7 @@ fp_device_finalize (GObject *object)
FpDevice *self = (FpDevice *) object; FpDevice *self = (FpDevice *) object;
FpDevicePrivate *priv = fp_device_get_instance_private (self); 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); g_assert (priv->current_task == NULL);
if (priv->is_open) if (priv->is_open)
g_warning ("User destroyed open device! Not cleaning up properly!"); g_warning ("User destroyed open device! Not cleaning up properly!");
@ -268,7 +268,7 @@ fp_device_async_initable_init_async (GAsyncInitable *initable,
return; return;
} }
priv->current_action = FP_DEVICE_ACTION_PROBE; priv->current_action = FPI_DEVICE_ACTION_PROBE;
priv->current_task = g_steal_pointer (&task); priv->current_task = g_steal_pointer (&task);
maybe_cancel_on_cancelled (self, cancellable); maybe_cancel_on_cancelled (self, cancellable);
@ -584,7 +584,7 @@ fp_device_open (FpDevice *device,
return; return;
} }
priv->current_action = FP_DEVICE_ACTION_OPEN; priv->current_action = FPI_DEVICE_ACTION_OPEN;
priv->current_task = g_steal_pointer (&task); priv->current_task = g_steal_pointer (&task);
maybe_cancel_on_cancelled (device, cancellable); maybe_cancel_on_cancelled (device, cancellable);
@ -648,7 +648,7 @@ fp_device_close (FpDevice *device,
return; return;
} }
priv->current_action = FP_DEVICE_ACTION_CLOSE; priv->current_action = FPI_DEVICE_ACTION_CLOSE;
priv->current_task = g_steal_pointer (&task); priv->current_task = g_steal_pointer (&task);
maybe_cancel_on_cancelled (device, cancellable); maybe_cancel_on_cancelled (device, cancellable);
@ -709,7 +709,7 @@ fp_device_enroll (FpDevice *device,
g_autoptr(GTask) task = NULL; g_autoptr(GTask) task = NULL;
FpDevicePrivate *priv = fp_device_get_instance_private (device); FpDevicePrivate *priv = fp_device_get_instance_private (device);
FpEnrollData *data; FpEnrollData *data;
FpPrintType print_type; FpiPrintType print_type;
task = g_task_new (device, cancellable, callback, user_data); task = g_task_new (device, cancellable, callback, user_data);
if (g_task_return_error_if_cancelled (task)) 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); 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_warning ("Passed print template must be newly created and blank!");
g_task_return_error (task, g_task_return_error (task,
@ -746,7 +746,7 @@ fp_device_enroll (FpDevice *device,
return; return;
} }
priv->current_action = FP_DEVICE_ACTION_ENROLL; priv->current_action = FPI_DEVICE_ACTION_ENROLL;
priv->current_task = g_steal_pointer (&task); priv->current_task = g_steal_pointer (&task);
maybe_cancel_on_cancelled (device, cancellable); maybe_cancel_on_cancelled (device, cancellable);
@ -822,7 +822,7 @@ fp_device_verify (FpDevice *device,
return; return;
} }
priv->current_action = FP_DEVICE_ACTION_VERIFY; priv->current_action = FPI_DEVICE_ACTION_VERIFY;
priv->current_task = g_steal_pointer (&task); priv->current_task = g_steal_pointer (&task);
maybe_cancel_on_cancelled (device, cancellable); maybe_cancel_on_cancelled (device, cancellable);
@ -915,7 +915,7 @@ fp_device_identify (FpDevice *device,
return; return;
} }
priv->current_action = FP_DEVICE_ACTION_IDENTIFY; priv->current_action = FPI_DEVICE_ACTION_IDENTIFY;
priv->current_task = g_steal_pointer (&task); priv->current_task = g_steal_pointer (&task);
maybe_cancel_on_cancelled (device, cancellable); maybe_cancel_on_cancelled (device, cancellable);
@ -1008,7 +1008,7 @@ fp_device_capture (FpDevice *device,
return; return;
} }
priv->current_action = FP_DEVICE_ACTION_CAPTURE; priv->current_action = FPI_DEVICE_ACTION_CAPTURE;
priv->current_task = g_steal_pointer (&task); priv->current_task = g_steal_pointer (&task);
maybe_cancel_on_cancelled (device, cancellable); maybe_cancel_on_cancelled (device, cancellable);
@ -1089,7 +1089,7 @@ fp_device_delete_print (FpDevice *device,
return; return;
} }
priv->current_action = FP_DEVICE_ACTION_DELETE; priv->current_action = FPI_DEVICE_ACTION_DELETE;
priv->current_task = g_steal_pointer (&task); priv->current_task = g_steal_pointer (&task);
maybe_cancel_on_cancelled (device, cancellable); maybe_cancel_on_cancelled (device, cancellable);
@ -1159,7 +1159,7 @@ fp_device_list_prints (FpDevice *device,
return; return;
} }
priv->current_action = FP_DEVICE_ACTION_LIST; priv->current_action = FPI_DEVICE_ACTION_LIST;
priv->current_task = g_steal_pointer (&task); priv->current_task = g_steal_pointer (&task);
maybe_cancel_on_cancelled (device, cancellable); maybe_cancel_on_cancelled (device, cancellable);

2
libfprint/fp-image-device-private.h
View file

@ -25,7 +25,7 @@
typedef struct typedef struct
{ {
FpImageDeviceState state; FpiImageDeviceState state;
gboolean active; gboolean active;
gboolean cancelling; gboolean cancelling;

30
libfprint/fp-image-device.c
View file

@ -106,7 +106,7 @@ fp_image_device_close (FpDevice *device)
if (!priv->active) if (!priv->active)
cls->img_close (self); 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); fpi_image_device_deactivate (self);
} }
@ -115,16 +115,16 @@ fp_image_device_cancel_action (FpDevice *device)
{ {
FpImageDevice *self = FP_IMAGE_DEVICE (device); FpImageDevice *self = FP_IMAGE_DEVICE (device);
FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self); FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
FpDeviceAction action; FpiDeviceAction action;
action = fpi_device_get_current_action (device); action = fpi_device_get_current_action (device);
/* We can only cancel capture operations, in that case, deactivate and return /* We can only cancel capture operations, in that case, deactivate and return
* an error immediately. */ * an error immediately. */
if (action == FP_DEVICE_ACTION_ENROLL || if (action == FPI_DEVICE_ACTION_ENROLL ||
action == FP_DEVICE_ACTION_VERIFY || action == FPI_DEVICE_ACTION_VERIFY ||
action == FP_DEVICE_ACTION_IDENTIFY || action == FPI_DEVICE_ACTION_IDENTIFY ||
action == FP_DEVICE_ACTION_CAPTURE) action == FPI_DEVICE_ACTION_CAPTURE)
{ {
priv->cancelling = TRUE; priv->cancelling = TRUE;
fpi_image_device_deactivate (self); fpi_image_device_deactivate (self);
@ -143,14 +143,14 @@ fp_image_device_start_capture_action (FpDevice *device)
{ {
FpImageDevice *self = FP_IMAGE_DEVICE (device); FpImageDevice *self = FP_IMAGE_DEVICE (device);
FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self); FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
FpDeviceAction action; FpiDeviceAction action;
/* There is just one action that we cannot support out /* There is just one action that we cannot support out
* of the box, which is a capture without first waiting * of the box, which is a capture without first waiting
* for a finger to be on the device. * for a finger to be on the device.
*/ */
action = fpi_device_get_current_action (device); action = fpi_device_get_current_action (device);
if (action == FP_DEVICE_ACTION_CAPTURE) if (action == FPI_DEVICE_ACTION_CAPTURE)
{ {
gboolean wait_for_finger; gboolean wait_for_finger;
@ -162,12 +162,12 @@ fp_image_device_start_capture_action (FpDevice *device)
return; return;
} }
} }
else if (action == FP_DEVICE_ACTION_ENROLL) else if (action == FPI_DEVICE_ACTION_ENROLL)
{ {
FpPrint *enroll_print = NULL; FpPrint *enroll_print = NULL;
fpi_device_get_enroll_data (device, &enroll_print); 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; 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 * error (which will usually say that the user should remove the
* finger). * 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_debug ("Got a new request while the device was still active");
g_assert (priv->pending_activation_timeout_id == 0); g_assert (priv->pending_activation_timeout_id == 0);
priv->pending_activation_timeout_id = priv->pending_activation_timeout_id =
g_timeout_add (100, pending_activation_timeout, device); 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; priv->pending_activation_timeout_waiting_finger_off = TRUE;
else else
priv->pending_activation_timeout_waiting_finger_off = FALSE; 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", g_param_spec_enum ("fp-image-device-state",
"Image Device State", "Image Device State",
"Private: The state of the image device", "Private: The state of the image device",
FP_TYPE_IMAGE_DEVICE_STATE, FPI_TYPE_IMAGE_DEVICE_STATE,
FP_IMAGE_DEVICE_STATE_INACTIVE, FPI_IMAGE_DEVICE_STATE_INACTIVE,
G_PARAM_STATIC_STRINGS | G_PARAM_READABLE); G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
signals[FPI_STATE_CHANGED] = signals[FPI_STATE_CHANGED] =
@ -281,7 +281,7 @@ fp_image_device_class_init (FpImageDeviceClass *klass)
G_SIGNAL_RUN_FIRST, G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (FpImageDeviceClass, change_state), G_STRUCT_OFFSET (FpImageDeviceClass, change_state),
NULL, NULL, NULL, 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); g_object_class_install_properties (object_class, N_PROPS, properties);
} }

2
libfprint/fp-print-private.h
View file

@ -27,7 +27,7 @@ struct _FpPrint
{ {
GInitiallyUnowned parent_instance; GInitiallyUnowned parent_instance;
FpPrintType type; FpiPrintType type;
gchar *driver; gchar *driver;
gchar *device_id; gchar *device_id;

28
libfprint/fp-print.c
View file

@ -272,8 +272,8 @@ fp_print_class_init (FpPrintClass *klass)
g_param_spec_enum ("fp-type", g_param_spec_enum ("fp-type",
"Type", "Type",
"Private: The type of the print data", "Private: The type of the print data",
FP_TYPE_PRINT_TYPE, FPI_TYPE_PRINT_TYPE,
FP_PRINT_RAW, FPI_PRINT_RAW,
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY); G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
properties[PROP_FPI_DATA] = 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 (self), FALSE);
g_return_val_if_fail (FP_IS_PRINT (other), 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 (self->type != FPI_PRINT_UNDEFINED, FALSE);
g_return_val_if_fail (other->type != FP_PRINT_UNDEFINED, FALSE); g_return_val_if_fail (other->type != FPI_PRINT_UNDEFINED, FALSE);
if (self->type != other->type) if (self->type != other->type)
return FALSE; return FALSE;
@ -567,11 +567,11 @@ fp_print_equal (FpPrint *self, FpPrint *other)
if (g_strcmp0 (self->device_id, other->device_id)) if (g_strcmp0 (self->device_id, other->device_id))
return FALSE; return FALSE;
if (self->type == FP_PRINT_RAW) if (self->type == FPI_PRINT_RAW)
{ {
return g_variant_equal (self->data, other->data); return g_variant_equal (self->data, other->data);
} }
else if (self->type == FP_PRINT_NBIS) else if (self->type == FPI_PRINT_NBIS)
{ {
gint i; 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); G_STATIC_ASSERT (sizeof (((struct xyt_struct *) NULL)->xcol[0]) == 4);
@ -618,7 +618,7 @@ fp_print_serialize (FpPrint *print,
GError **error) GError **error)
{ {
g_autoptr(GVariant) result = NULL; 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; gsize len;
g_assert (data); g_assert (data);
@ -643,7 +643,7 @@ fp_print_serialize (FpPrint *print,
g_variant_builder_close (&builder); g_variant_builder_close (&builder);
/* Insert NBIS print data for type NBIS, otherwise the GVariant directly */ /* 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))")); GVariantBuilder nested = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE ("(a(aiaiai))"));
gint i; gint i;
@ -745,7 +745,7 @@ fp_print_deserialize (const guchar *data,
g_autofree gchar *username = NULL; g_autofree gchar *username = NULL;
g_autofree gchar *description = NULL; g_autofree gchar *description = NULL;
gint julian_date; gint julian_date;
FpPrintType type; FpiPrintType type;
const gchar *driver; const gchar *driver;
const gchar *device_id; const gchar *device_id;
gboolean device_stored; gboolean device_stored;
@ -766,7 +766,7 @@ fp_print_deserialize (const guchar *data,
* longer. */ * longer. */
aligned_data = g_malloc (length - 3); aligned_data = g_malloc (length - 3);
memcpy (aligned_data, data + 3, 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, aligned_data, length - 3,
FALSE, g_free, aligned_data); FALSE, g_free, aligned_data);
@ -794,7 +794,7 @@ fp_print_deserialize (const guchar *data,
finger = finger_int8; finger = finger_int8;
/* Assume data is valid at this point if the values are somewhat sane. */ /* 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); g_autoptr(GVariant) prints = g_variant_get_child_value (print_data, 0);
gint i; gint i;
@ -804,7 +804,7 @@ fp_print_deserialize (const guchar *data,
"device-id", device_id, "device-id", device_id,
"device-stored", device_stored, "device-stored", device_stored,
NULL); 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++) for (i = 0; i < g_variant_n_children (prints); i++)
{ {
g_autofree struct xyt_struct *xyt = g_new0 (struct xyt_struct, 1); 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)); 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); g_autoptr(GVariant) fp_data = g_variant_get_child_value (print_data, 0);

66
libfprint/fpi-device.c
View file

@ -350,21 +350,21 @@ fpi_device_get_virtual_env (FpDevice *device)
* fpi_device_get_current_action: * fpi_device_get_current_action:
* @device: The #FpDevice * @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. * is no operation at this time.
* *
* This is useful for drivers that might share code paths between different * 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 * actions (e.g. verify and identify) and want to find out again later which
* action was started in the beginning. * action was started in the beginning.
* *
* Returns: The ongoing #FpDeviceAction * Returns: The ongoing #FpiDeviceAction
*/ */
FpDeviceAction FpiDeviceAction
fpi_device_get_current_action (FpDevice *device) fpi_device_get_current_action (FpDevice *device)
{ {
FpDevicePrivate *priv = fp_device_get_instance_private (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; return priv->current_action;
} }
@ -387,7 +387,7 @@ fpi_device_action_is_cancelled (FpDevice *device)
GCancellable *cancellable; GCancellable *cancellable;
g_return_val_if_fail (FP_IS_DEVICE (device), TRUE); 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); cancellable = g_task_get_cancellable (priv->current_task);
@ -435,7 +435,7 @@ fpi_device_get_enroll_data (FpDevice *device,
FpEnrollData *data; FpEnrollData *data;
g_return_if_fail (FP_IS_DEVICE (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);
data = g_task_get_task_data (priv->current_task); data = g_task_get_task_data (priv->current_task);
g_assert (data); g_assert (data);
@ -458,7 +458,7 @@ fpi_device_get_capture_data (FpDevice *device,
FpDevicePrivate *priv = fp_device_get_instance_private (device); FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (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) if (wait_for_finger)
*wait_for_finger = priv->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); FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (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) if (print)
*print = g_task_get_task_data (priv->current_task); *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); FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (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) if (prints)
*prints = g_task_get_task_data (priv->current_task); *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); FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (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) if (print)
*print = g_task_get_task_data (priv->current_task); *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); FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_val_if_fail (FP_IS_DEVICE (device), NULL); 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); 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); FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (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) if (error != NULL)
{ {
@ -579,44 +579,44 @@ fpi_device_action_error (FpDevice *device,
switch (priv->current_action) switch (priv->current_action)
{ {
case FP_DEVICE_ACTION_PROBE: case FPI_DEVICE_ACTION_PROBE:
fpi_device_probe_complete (device, NULL, NULL, error); fpi_device_probe_complete (device, NULL, NULL, error);
break; break;
case FP_DEVICE_ACTION_OPEN: case FPI_DEVICE_ACTION_OPEN:
fpi_device_open_complete (device, error); fpi_device_open_complete (device, error);
break; break;
case FP_DEVICE_ACTION_CLOSE: case FPI_DEVICE_ACTION_CLOSE:
fpi_device_close_complete (device, error); fpi_device_close_complete (device, error);
break; break;
case FP_DEVICE_ACTION_ENROLL: case FPI_DEVICE_ACTION_ENROLL:
fpi_device_enroll_complete (device, NULL, error); fpi_device_enroll_complete (device, NULL, error);
break; break;
case FP_DEVICE_ACTION_VERIFY: case FPI_DEVICE_ACTION_VERIFY:
fpi_device_verify_complete (device, FPI_MATCH_ERROR, NULL, error); fpi_device_verify_complete (device, FPI_MATCH_ERROR, NULL, error);
break; break;
case FP_DEVICE_ACTION_IDENTIFY: case FPI_DEVICE_ACTION_IDENTIFY:
fpi_device_identify_complete (device, NULL, NULL, error); fpi_device_identify_complete (device, NULL, NULL, error);
break; break;
case FP_DEVICE_ACTION_CAPTURE: case FPI_DEVICE_ACTION_CAPTURE:
fpi_device_capture_complete (device, NULL, error); fpi_device_capture_complete (device, NULL, error);
break; break;
case FP_DEVICE_ACTION_DELETE: case FPI_DEVICE_ACTION_DELETE:
fpi_device_delete_complete (device, error); fpi_device_delete_complete (device, error);
break; break;
case FP_DEVICE_ACTION_LIST: case FPI_DEVICE_ACTION_LIST:
fpi_device_list_complete (device, NULL, error); fpi_device_list_complete (device, NULL, error);
break; break;
default: default:
case FP_DEVICE_ACTION_NONE: case FPI_DEVICE_ACTION_NONE:
g_return_if_reached (); g_return_if_reached ();
break; 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); g_debug ("Completing action %d in idle!", priv->current_action);
task = g_steal_pointer (&priv->current_task); 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; priv->current_task_idle_return_source = NULL;
switch (data->type) switch (data->type)
@ -746,7 +746,7 @@ fpi_device_probe_complete (FpDevice *device,
FpDevicePrivate *priv = fp_device_get_instance_private (device); FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (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"); 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); FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (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"); 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); FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (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"); 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); FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (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"); g_debug ("Device reported enroll completion");
@ -923,7 +923,7 @@ fpi_device_verify_complete (FpDevice *device,
FpDevicePrivate *priv = fp_device_get_instance_private (device); FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (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"); g_debug ("Device reported verify completion");
@ -980,7 +980,7 @@ fpi_device_identify_complete (FpDevice *device,
FpDevicePrivate *priv = fp_device_get_instance_private (device); FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (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"); g_debug ("Device reported identify completion");
@ -1027,7 +1027,7 @@ fpi_device_capture_complete (FpDevice *device,
FpDevicePrivate *priv = fp_device_get_instance_private (device); FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (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"); g_debug ("Device reported capture completion");
@ -1072,7 +1072,7 @@ fpi_device_delete_complete (FpDevice *device,
FpDevicePrivate *priv = fp_device_get_instance_private (device); FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (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"); g_debug ("Device reported deletion completion");
@ -1106,7 +1106,7 @@ fpi_device_list_complete (FpDevice *device,
FpDevicePrivate *priv = fp_device_get_instance_private (device); FpDevicePrivate *priv = fp_device_get_instance_private (device);
g_return_if_fail (FP_IS_DEVICE (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"); g_debug ("Device reported listing completion");
@ -1150,7 +1150,7 @@ fpi_device_enroll_progress (FpDevice *device,
FpEnrollData *data; FpEnrollData *data;
g_return_if_fail (FP_IS_DEVICE (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_return_if_fail (error == NULL || error->domain == FP_DEVICE_RETRY); 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); g_debug ("Device reported enroll progress, reported %i of %i have been completed", completed_stages, priv->nr_enroll_stages);

46
libfprint/fpi-device.h
View file

@ -142,39 +142,39 @@ typedef void (*FpTimeoutFunc) (FpDevice *device,
gpointer user_data); gpointer user_data);
/** /**
* FpDeviceAction: * FpiDeviceAction:
* @FP_DEVICE_ACTION_NONE: No action is active. * @FPI_DEVICE_ACTION_NONE: No action is active.
* @FP_DEVICE_ACTION_PROBE: Probe device for support and information. * @FPI_DEVICE_ACTION_PROBE: Probe device for support and information.
* @FP_DEVICE_ACTION_OPEN: Device is currently being opened. * @FPI_DEVICE_ACTION_OPEN: Device is currently being opened.
* @FP_DEVICE_ACTION_CLOSE: Device is currently being closed. * @FPI_DEVICE_ACTION_CLOSE: Device is currently being closed.
* @FP_DEVICE_ACTION_ENROLL: Device is currently enrolling. * @FPI_DEVICE_ACTION_ENROLL: Device is currently enrolling.
* @FP_DEVICE_ACTION_VERIFY: Device is currently verifying. * @FPI_DEVICE_ACTION_VERIFY: Device is currently verifying.
* @FP_DEVICE_ACTION_IDENTIFY: Device is currently identifying. * @FPI_DEVICE_ACTION_IDENTIFY: Device is currently identifying.
* @FP_DEVICE_ACTION_CAPTURE: Device is currently capturing an image. * @FPI_DEVICE_ACTION_CAPTURE: Device is currently capturing an image.
* @FP_DEVICE_ACTION_LIST: Device stored prints are being queried. * @FPI_DEVICE_ACTION_LIST: Device stored prints are being queried.
* @FP_DEVICE_ACTION_DELETE: Device stored print is being deleted. * @FPI_DEVICE_ACTION_DELETE: Device stored print is being deleted.
* *
* Current active action of the device. A driver can retrieve the action. * Current active action of the device. A driver can retrieve the action.
*/ */
typedef enum { typedef enum {
FP_DEVICE_ACTION_NONE = 0, FPI_DEVICE_ACTION_NONE = 0,
FP_DEVICE_ACTION_PROBE, FPI_DEVICE_ACTION_PROBE,
FP_DEVICE_ACTION_OPEN, FPI_DEVICE_ACTION_OPEN,
FP_DEVICE_ACTION_CLOSE, FPI_DEVICE_ACTION_CLOSE,
FP_DEVICE_ACTION_ENROLL, FPI_DEVICE_ACTION_ENROLL,
FP_DEVICE_ACTION_VERIFY, FPI_DEVICE_ACTION_VERIFY,
FP_DEVICE_ACTION_IDENTIFY, FPI_DEVICE_ACTION_IDENTIFY,
FP_DEVICE_ACTION_CAPTURE, FPI_DEVICE_ACTION_CAPTURE,
FP_DEVICE_ACTION_LIST, FPI_DEVICE_ACTION_LIST,
FP_DEVICE_ACTION_DELETE, FPI_DEVICE_ACTION_DELETE,
} FpDeviceAction; } FpiDeviceAction;
GUsbDevice *fpi_device_get_usb_device (FpDevice *device); GUsbDevice *fpi_device_get_usb_device (FpDevice *device);
const gchar *fpi_device_get_virtual_env (FpDevice *device); const gchar *fpi_device_get_virtual_env (FpDevice *device);
//const gchar *fpi_device_get_spi_dev (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); gboolean fpi_device_action_is_cancelled (FpDevice *device);
GError * fpi_device_retry_new (FpDeviceRetry error); GError * fpi_device_retry_new (FpDeviceRetry error);

104
libfprint/fpi-image-device.c
View file

@ -54,7 +54,7 @@ fpi_image_device_activate (FpImageDevice *self)
/* We don't have a neutral ACTIVE state, but we always will /* We don't have a neutral ACTIVE state, but we always will
* go into WAIT_FINGER_ON afterwards. */ * 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"); g_object_notify (G_OBJECT (self), "fp-image-device-state");
/* We might have been waiting for deactivation to finish before /* 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."); fp_dbg ("Already deactivated, ignoring request.");
return; 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."); 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"); g_object_notify (G_OBJECT (self), "fp-image-device-state");
fp_dbg ("Deactivating image device\n"); fp_dbg ("Deactivating image device\n");
@ -92,12 +92,12 @@ fpi_image_device_deactivate (FpImageDevice *self)
/* Static helper functions */ /* Static helper functions */
static void 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); FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
/* Cannot change to inactive using this function. */ /* 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 /* We might have been waiting for the finger to go OFF to start the
* next operation. */ * next operation. */
@ -118,7 +118,7 @@ fp_image_device_enroll_maybe_await_finger_on (FpImageDevice *self)
if (priv->enroll_await_on_pending) if (priv->enroll_await_on_pending)
{ {
priv->enroll_await_on_pending = FALSE; 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 else
{ {
@ -135,7 +135,7 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
FpImageDevice *self = FP_IMAGE_DEVICE (user_data); FpImageDevice *self = FP_IMAGE_DEVICE (user_data);
FpDevice *device = FP_DEVICE (self); FpDevice *device = FP_DEVICE (self);
FpImageDevicePrivate *priv; FpImageDevicePrivate *priv;
FpDeviceAction action; FpiDeviceAction action;
/* Note: We rely on the device to not disappear during an operation. */ /* 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)); priv = fp_image_device_get_instance_private (FP_IMAGE_DEVICE (device));
action = fpi_device_get_current_action (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_device_capture_complete (device, g_steal_pointer (&image), error);
fpi_image_device_deactivate (self); fpi_image_device_deactivate (self);
@ -169,12 +169,12 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
if (!error) if (!error)
{ {
print = fp_print_new (device); 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)) if (!fpi_print_add_from_image (print, image, &error))
g_clear_object (&print); g_clear_object (&print);
} }
if (action == FP_DEVICE_ACTION_ENROLL) if (action == FPI_DEVICE_ACTION_ENROLL)
{ {
FpPrint *enroll_print; FpPrint *enroll_print;
fpi_device_get_enroll_data (device, &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)); 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; FpPrint *template;
FpiMatchResult result; 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_device_verify_complete (device, result, g_steal_pointer (&print), error);
fpi_image_device_deactivate (self); fpi_image_device_deactivate (self);
} }
else if (action == FP_DEVICE_ACTION_IDENTIFY) else if (action == FPI_DEVICE_ACTION_IDENTIFY)
{ {
gint i; gint i;
GPtrArray *templates; GPtrArray *templates;
@ -285,9 +285,9 @@ fpi_image_device_report_finger_status (FpImageDevice *self,
{ {
FpDevice *device = FP_DEVICE (self); FpDevice *device = FP_DEVICE (self);
FpImageDevicePrivate *priv = fp_image_device_get_instance_private (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 /* Do we really want to always ignore such reports? We could
* also track the state in case the user had the finger on * 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); action = fpi_device_get_current_action (device);
g_assert (action != FP_DEVICE_ACTION_OPEN); g_assert (action != FPI_DEVICE_ACTION_OPEN);
g_assert (action != FP_DEVICE_ACTION_CLOSE); g_assert (action != FPI_DEVICE_ACTION_CLOSE);
g_debug ("Image device reported finger status: %s", present ? "on" : "off"); 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 */ /* 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) * minutiae detection to prevent deactivation (without cancellation)
* from the AWAIT_FINGER_ON state. * from the AWAIT_FINGER_ON state.
*/ */
if (action != FP_DEVICE_ACTION_ENROLL) if (action != FPI_DEVICE_ACTION_ENROLL)
fpi_image_device_deactivate (self); fpi_image_device_deactivate (self);
else else
fp_image_device_enroll_maybe_await_finger_on (self); fp_image_device_enroll_maybe_await_finger_on (self);
@ -349,18 +349,18 @@ void
fpi_image_device_image_captured (FpImageDevice *self, FpImage *image) fpi_image_device_image_captured (FpImageDevice *self, FpImage *image)
{ {
FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self); FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
FpDeviceAction action; FpiDeviceAction action;
action = fpi_device_get_current_action (FP_DEVICE (self)); action = fpi_device_get_current_action (FP_DEVICE (self));
g_return_if_fail (image != NULL); g_return_if_fail (image != NULL);
g_return_if_fail (priv->state == FP_IMAGE_DEVICE_STATE_CAPTURE); g_return_if_fail (priv->state == FPI_IMAGE_DEVICE_STATE_CAPTURE);
g_return_if_fail (action == FP_DEVICE_ACTION_ENROLL || g_return_if_fail (action == FPI_DEVICE_ACTION_ENROLL ||
action == FP_DEVICE_ACTION_VERIFY || action == FPI_DEVICE_ACTION_VERIFY ||
action == FP_DEVICE_ACTION_IDENTIFY || action == FPI_DEVICE_ACTION_IDENTIFY ||
action == FP_DEVICE_ACTION_CAPTURE); 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"); g_debug ("Image device captured an image");
@ -385,22 +385,22 @@ void
fpi_image_device_retry_scan (FpImageDevice *self, FpDeviceRetry retry) fpi_image_device_retry_scan (FpImageDevice *self, FpDeviceRetry retry)
{ {
FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self); FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
FpDeviceAction action; FpiDeviceAction action;
GError *error; GError *error;
action = fpi_device_get_current_action (FP_DEVICE (self)); action = fpi_device_get_current_action (FP_DEVICE (self));
/* We might be waiting for a finger at this point, so just accept /* We might be waiting for a finger at this point, so just accept
* all but INACTIVE */ * all but INACTIVE */
g_return_if_fail (priv->state != FP_IMAGE_DEVICE_STATE_INACTIVE); g_return_if_fail (priv->state != FPI_IMAGE_DEVICE_STATE_INACTIVE);
g_return_if_fail (action == FP_DEVICE_ACTION_ENROLL || g_return_if_fail (action == FPI_DEVICE_ACTION_ENROLL ||
action == FP_DEVICE_ACTION_VERIFY || action == FPI_DEVICE_ACTION_VERIFY ||
action == FP_DEVICE_ACTION_IDENTIFY || action == FPI_DEVICE_ACTION_IDENTIFY ||
action == FP_DEVICE_ACTION_CAPTURE); action == FPI_DEVICE_ACTION_CAPTURE);
error = fpi_device_retry_new (retry); error = fpi_device_retry_new (retry);
if (action == FP_DEVICE_ACTION_ENROLL) if (action == FPI_DEVICE_ACTION_ENROLL)
{ {
g_debug ("Reporting retry during enroll"); g_debug ("Reporting retry during enroll");
fpi_device_enroll_progress (FP_DEVICE (self), priv->enroll_stage, NULL, error); 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) 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."); 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!"); g_warning ("Translating to activation failure!");
fpi_image_device_activate_complete (self, error); fpi_image_device_activate_complete (self, error);
return; 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."); g_warning ("Driver reported session error; translating to deactivation failure.");
fpi_image_device_deactivate_complete (self, error); fpi_image_device_deactivate_complete (self, error);
@ -473,15 +473,15 @@ void
fpi_image_device_activate_complete (FpImageDevice *self, GError *error) fpi_image_device_activate_complete (FpImageDevice *self, GError *error)
{ {
FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self); FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
FpDeviceAction action; FpiDeviceAction action;
action = fpi_device_get_current_action (FP_DEVICE (self)); action = fpi_device_get_current_action (FP_DEVICE (self));
g_return_if_fail (priv->active == FALSE); g_return_if_fail (priv->active == FALSE);
g_return_if_fail (action == FP_DEVICE_ACTION_ENROLL || g_return_if_fail (action == FPI_DEVICE_ACTION_ENROLL ||
action == FP_DEVICE_ACTION_VERIFY || action == FPI_DEVICE_ACTION_VERIFY ||
action == FP_DEVICE_ACTION_IDENTIFY || action == FPI_DEVICE_ACTION_IDENTIFY ||
action == FP_DEVICE_ACTION_CAPTURE); action == FPI_DEVICE_ACTION_CAPTURE);
if (error) 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 /* We always want to capture at this point, move to AWAIT_FINGER
* state. */ * 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); FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
FpImageDeviceClass *cls = FP_IMAGE_DEVICE_GET_CLASS (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->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"); 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 /* Special case, if we should be closing, but didn't due to a running
* deactivation, then do so now. */ * deactivation, then do so now. */
if (action == FP_DEVICE_ACTION_CLOSE) if (action == FPI_DEVICE_ACTION_CLOSE)
{ {
cls->img_close (self); cls->img_close (self);
return; return;
@ -553,16 +553,16 @@ void
fpi_image_device_open_complete (FpImageDevice *self, GError *error) fpi_image_device_open_complete (FpImageDevice *self, GError *error)
{ {
FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self); FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
FpDeviceAction action; FpiDeviceAction action;
action = fpi_device_get_current_action (FP_DEVICE (self)); action = fpi_device_get_current_action (FP_DEVICE (self));
g_return_if_fail (priv->active == FALSE); 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"); 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"); g_object_notify (G_OBJECT (self), "fp-image-device-state");
fpi_device_open_complete (FP_DEVICE (self), error); fpi_device_open_complete (FP_DEVICE (self), error);
@ -579,16 +579,16 @@ void
fpi_image_device_close_complete (FpImageDevice *self, GError *error) fpi_image_device_close_complete (FpImageDevice *self, GError *error)
{ {
FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self); FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
FpDeviceAction action; FpiDeviceAction action;
action = fpi_device_get_current_action (FP_DEVICE (self)); action = fpi_device_get_current_action (FP_DEVICE (self));
g_debug ("Image device close completed"); g_debug ("Image device close completed");
g_return_if_fail (priv->active == FALSE); 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"); g_object_notify (G_OBJECT (self), "fp-image-device-state");
fpi_device_close_complete (FP_DEVICE (self), error); fpi_device_close_complete (FP_DEVICE (self), error);

22
libfprint/fpi-image-device.h
View file

@ -23,11 +23,11 @@
#include "fp-image-device.h" #include "fp-image-device.h"
/** /**
* FpImageDeviceState: * FpiImageDeviceState:
* @FP_IMAGE_DEVICE_STATE_INACTIVE: inactive * @FPI_IMAGE_DEVICE_STATE_INACTIVE: inactive
* @FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON: waiting for the finger to be pressed or swiped * @FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON: waiting for the finger to be pressed or swiped
* @FP_IMAGE_DEVICE_STATE_CAPTURE: capturing an image * @FPI_IMAGE_DEVICE_STATE_CAPTURE: capturing an image
* @FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF: waiting for the finger to be removed * @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 * 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. * passed through to the driver using the ::activate() or ::change_state() vfuncs.
@ -37,11 +37,11 @@
* unconditionally if the device supports raw capturing. * unconditionally if the device supports raw capturing.
*/ */
typedef enum { typedef enum {
FP_IMAGE_DEVICE_STATE_INACTIVE, FPI_IMAGE_DEVICE_STATE_INACTIVE,
FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON, FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON,
FP_IMAGE_DEVICE_STATE_CAPTURE, FPI_IMAGE_DEVICE_STATE_CAPTURE,
FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF, FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF,
} FpImageDeviceState; } FpiImageDeviceState;
/** /**
* FpImageDeviceClass: * FpImageDeviceClass:
@ -91,7 +91,7 @@ struct _FpImageDeviceClass
void (*img_close) (FpImageDevice *dev); void (*img_close) (FpImageDevice *dev);
void (*activate) (FpImageDevice *dev); void (*activate) (FpImageDevice *dev);
void (*change_state) (FpImageDevice *dev, void (*change_state) (FpImageDevice *dev,
FpImageDeviceState state); FpiImageDeviceState state);
void (*deactivate) (FpImageDevice *dev); void (*deactivate) (FpImageDevice *dev);
}; };

22
libfprint/fpi-print.c
View file

@ -38,15 +38,15 @@
* @print: A #FpPrint * @print: A #FpPrint
* @add: Print to append to @print * @add: Print to append to @print
* *
* Appends the single #FP_PRINT_NBIS print from @add to the collection of * Appends the single #FPI_PRINT_NBIS print from @add to the collection of
* prints in @print. Both print objects need to be of type #FP_PRINT_NBIS * prints in @print. Both print objects need to be of type #FPI_PRINT_NBIS
* for this to work. * for this to work.
*/ */
void void
fpi_print_add_print (FpPrint *print, FpPrint *add) fpi_print_add_print (FpPrint *print, FpPrint *add)
{ {
g_return_if_fail (print->type == FP_PRINT_NBIS); g_return_if_fail (print->type == FPI_PRINT_NBIS);
g_return_if_fail (add->type == FP_PRINT_NBIS); g_return_if_fail (add->type == FPI_PRINT_NBIS);
g_assert (add->prints->len == 1); g_assert (add->prints->len == 1);
g_ptr_array_add (print->prints, g_memdup (add->prints->pdata[0], sizeof (struct xyt_struct))); g_ptr_array_add (print->prints, g_memdup (add->prints->pdata[0], sizeof (struct xyt_struct)));
@ -63,14 +63,14 @@ fpi_print_add_print (FpPrint *print, FpPrint *add)
*/ */
void void
fpi_print_set_type (FpPrint *print, fpi_print_set_type (FpPrint *print,
FpPrintType type) FpiPrintType type)
{ {
g_return_if_fail (FP_IS_PRINT (print)); g_return_if_fail (FP_IS_PRINT (print));
/* We only allow setting this once! */ /* 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; print->type = type;
if (print->type == FP_PRINT_NBIS) if (print->type == FPI_PRINT_NBIS)
{ {
g_assert_null (print->prints); g_assert_null (print->prints);
print->prints = g_ptr_array_new_with_free_func (g_free); 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 * @error: Return location for error
* *
* Extracts the minutiae from the given image and adds it to @print of * 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. * The @image will be kept so that API users can get retrieve it e.g.
* for debugging purposes. * for debugging purposes.
@ -159,7 +159,7 @@ fpi_print_add_from_image (FpPrint *print,
struct fp_minutiae _minutiae; struct fp_minutiae _minutiae;
struct xyt_struct *xyt; struct xyt_struct *xyt;
if (print->type != FP_PRINT_NBIS || !image) if (print->type != FPI_PRINT_NBIS || !image)
{ {
g_set_error (error, g_set_error (error,
G_IO_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 * Match the newly scanned @print (containing exactly one print) against the
* prints contained in @template which will have been stored during enrollment. * 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. * work.
* *
* Returns: Whether the prints match, @error will be set if #FPI_MATCH_ERROR is returned * 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; gint i;
/* XXX: Use a different error type? */ /* 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, *error = fpi_device_error_new_msg (FP_DEVICE_ERROR_NOT_SUPPORTED,
"It is only possible to match NBIS type print data"); "It is only possible to match NBIS type print data");

18
libfprint/fpi-print.h
View file

@ -7,16 +7,16 @@
G_BEGIN_DECLS G_BEGIN_DECLS
/** /**
* FpPrintType: * FpiPrintType:
* @FP_PRINT_UNDEFINED: Undefined type, this happens prior to enrollment * @FPI_PRINT_UNDEFINED: Undefined type, this happens prior to enrollment
* @FP_PRINT_RAW: A raw print where the data is directly compared * @FPI_PRINT_RAW: A raw print where the data is directly compared
* @FP_PRINT_NBIS: NBIS minutiae comparison * @FPI_PRINT_NBIS: NBIS minutiae comparison
*/ */
typedef enum { typedef enum {
FP_PRINT_UNDEFINED = 0, FPI_PRINT_UNDEFINED = 0,
FP_PRINT_RAW, FPI_PRINT_RAW,
FP_PRINT_NBIS, FPI_PRINT_NBIS,
} FpPrintType; } FpiPrintType;
/** /**
* FpiMatchResult: * FpiMatchResult:
@ -34,7 +34,7 @@ void fpi_print_add_print (FpPrint *print,
FpPrint *add); FpPrint *add);
void fpi_print_set_type (FpPrint *print, void fpi_print_set_type (FpPrint *print,
FpPrintType type); FpiPrintType type);
void fpi_print_set_device_stored (FpPrint *print, void fpi_print_set_device_stored (FpPrint *print,
gboolean device_stored); gboolean device_stored);

20
tests/test-device-fake.c
View file

@ -35,7 +35,7 @@ fpi_device_fake_probe (FpDevice *device)
FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device); FpDeviceClass *dev_class = FP_DEVICE_GET_CLASS (device);
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (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; fake_dev->last_called_function = fpi_device_fake_probe;
fpi_device_probe_complete (device, dev_class->id, dev_class->full_name, 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); 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; fake_dev->last_called_function = fpi_device_fake_open;
fpi_device_open_complete (device, fake_dev->ret_error); 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); 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; fake_dev->last_called_function = fpi_device_fake_close;
fpi_device_close_complete (device, fake_dev->ret_error); 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); FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
FpPrint *print = fake_dev->ret_print; 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); fpi_device_get_enroll_data (device, (FpPrint **) &fake_dev->action_data);
if (!print && !fake_dev->ret_error) if (!print && !fake_dev->ret_error)
@ -86,7 +86,7 @@ fpi_device_fake_verify (FpDevice *device)
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device); FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
FpPrint *print = fake_dev->ret_print; 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); fpi_device_get_verify_data (device, (FpPrint **) &fake_dev->action_data);
if (!print && !fake_dev->ret_error) if (!print && !fake_dev->ret_error)
@ -103,7 +103,7 @@ fpi_device_fake_identify (FpDevice *device)
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device); FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
FpPrint *match = fake_dev->ret_match; 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); fpi_device_get_identify_data (device, (GPtrArray **) &fake_dev->action_data);
if (!match && !fake_dev->ret_error) if (!match && !fake_dev->ret_error)
@ -135,7 +135,7 @@ fpi_device_fake_capture (FpDevice *device)
{ {
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (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); fpi_device_get_capture_data (device, (gboolean *) &fake_dev->action_data);
fake_dev->last_called_function = fpi_device_fake_capture; 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); 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; fake_dev->last_called_function = fpi_device_fake_list;
fpi_device_list_complete (device, fake_dev->ret_list, fake_dev->ret_error); 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); 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); fpi_device_get_delete_data (device, (gpointer) & fake_dev->action_data);
fake_dev->last_called_function = fpi_device_fake_delete; 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); 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; fake_dev->last_called_function = fpi_device_fake_cancel;
} }

20
tests/test-fpi-device.c
View file

@ -528,7 +528,7 @@ test_driver_enroll_progress (void)
device = auto_close_fake_device_new (); device = auto_close_fake_device_new ();
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, 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); fpi_device_enroll_progress (device, 0, NULL, NULL);
g_test_assert_expected_messages (); 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_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 static void
@ -997,7 +997,7 @@ test_driver_current_action_open_vfunc (FpDevice *device)
{ {
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (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; fake_dev->last_called_function = test_driver_current_action_open_vfunc;
fpi_device_open_complete (device, NULL); fpi_device_open_complete (device, NULL);
@ -1015,7 +1015,7 @@ test_driver_current_action_open (void)
fake_dev = FPI_DEVICE_FAKE (device); fake_dev = FPI_DEVICE_FAKE (device);
g_assert (fake_dev->last_called_function == test_driver_current_action_open_vfunc); 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 static void
@ -1023,7 +1023,7 @@ test_driver_action_get_cancellable_open_vfunc (FpDevice *device)
{ {
FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (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; fake_dev->last_called_function = test_driver_action_get_cancellable_open_vfunc;
g_assert_true (G_IS_CANCELLABLE (fpi_device_get_cancellable (device))); 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); 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; fake_dev->last_called_function = test_driver_action_get_cancellable_open_fail_vfunc;
g_assert_false (G_IS_CANCELLABLE (fpi_device_get_cancellable (device))); 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_autoptr(FpDevice) device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, 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_assert_null (fpi_device_get_cancellable (device));
g_test_assert_expected_messages (); 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); 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; fake_dev->last_called_function = test_driver_action_is_cancelled_open_vfunc;
g_assert_true (G_IS_CANCELLABLE (fpi_device_get_cancellable (device))); 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_autoptr(FpDevice) device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, 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_assert_true (fpi_device_action_is_cancelled (device));
g_test_assert_expected_messages (); 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_autoptr(FpDevice) device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, 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); fpi_device_action_error (device, NULL);
g_test_assert_expected_messages (); g_test_assert_expected_messages ();
} }