From c8e1269f61074aca1a976f578d40ee62013456a0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= Date: Mon, 16 Dec 2019 22:45:00 +0100 Subject: [PATCH] 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 fpi-device FpDeviceClass FpTimeoutFunc -FpDeviceAction +FpiDeviceAction FpIdEntry fpi_device_get_usb_device fpi_device_get_virtual_env @@ -173,7 +173,7 @@ fpi_image_resize
fpi-image-device FpImageDevice -FpImageDeviceState +FpiImageDeviceState FpImageDeviceClass fpi_image_device_session_error fpi_image_device_open_complete @@ -197,7 +197,7 @@ BUG
fpi-print -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 Base class for image devices FpImageDevice FpImageDeviceClass -FpImageDeviceState +FpiImageDeviceState
@@ -114,5 +114,3 @@ FpUsbTransferCallback FP_USB_ENDPOINT_IN FP_USB_ENDPOINT_OUT
- - 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 (); }