From 44152f201b938100ea12a1eb049e6fcfafc7aea0 Mon Sep 17 00:00:00 2001

From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= <mail@3v1n0.net>

Date: Mon, 16 Dec 2019 22:45:00 +0100

Subject: [PATCH 147/181] cleanup: Use FPI prefix for all the internal enum

 types

---

 doc/libfprint-sections.txt              |   6 +-

 doc/libfprint-sections.txt-new-manual   |   4 +-

 libfprint/drivers/elan.c                |  60 +++++++-------

 libfprint/drivers/elan.h                |   4 +-

 libfprint/drivers/synaptics/synaptics.c |   4 +-

 libfprint/drivers/uru4000.c             |  24 +++---

 libfprint/fp-device-private.h           |   2 +-

 libfprint/fp-device.c                   |  26 +++---

 libfprint/fp-image-device-private.h     |  16 ++--

 libfprint/fp-image-device.c             |  30 +++----

 libfprint/fp-print-private.h            |   2 +-

 libfprint/fp-print.c                    |  28 +++----

 libfprint/fpi-device.c                  |  66 +++++++--------

 libfprint/fpi-device.h                  |  46 +++++------

 libfprint/fpi-image-device.c            | 104 ++++++++++++------------

 libfprint/fpi-image-device.h            |  24 +++---

 libfprint/fpi-print.c                   |  24 +++---

 libfprint/fpi-print.h                   |  20 ++---

 tests/test-device-fake.c                |  20 ++---

 tests/test-fpi-device.c                 |  20 ++---

 20 files changed, 264 insertions(+), 266 deletions(-)

diff --git a/doc/libfprint-sections.txt b/doc/libfprint-sections.txt

index 9e17f8e..30a4e9b 100644

--- a/doc/libfprint-sections.txt

+++ b/doc/libfprint-sections.txt

@@ -129,7 +129,7 @@ fpi_get_driver_types

 <FILE>fpi-device</FILE>

 FpDeviceClass

 FpTimeoutFunc

-FpDeviceAction

+FpiDeviceAction

 FpIdEntry

 fpi_device_get_usb_device

 fpi_device_get_virtual_env

@@ -173,7 +173,7 @@ fpi_image_resize

 <SECTION>

 <FILE>fpi-image-device</FILE>

 <TITLE>FpImageDevice</TITLE>

-FpImageDeviceState

+FpiImageDeviceState

 FpImageDeviceClass

 fpi_image_device_session_error

 fpi_image_device_open_complete

@@ -197,7 +197,7 @@ BUG

 <SECTION>

 <FILE>fpi-print</FILE>

-FpPrintType

+FpiPrintType

 FpiMatchResult

 fpi_print_add_print

 fpi_print_set_type

diff --git a/doc/libfprint-sections.txt-new-manual b/doc/libfprint-sections.txt-new-manual

index 857425b..da850db 100644

--- a/doc/libfprint-sections.txt-new-manual

+++ b/doc/libfprint-sections.txt-new-manual

@@ -90,7 +90,7 @@ fp_image_get_width

 <TITLE>Base class for image devices</TITLE>

 FpImageDevice

 FpImageDeviceClass

-FpImageDeviceState

+FpiImageDeviceState

 </SECTION>

 <SECTION>

@@ -114,5 +114,3 @@ FpUsbTransferCallback

 FP_USB_ENDPOINT_IN

 FP_USB_ENDPOINT_OUT

 </SECTION>

-

-

diff --git a/libfprint/drivers/elan.c b/libfprint/drivers/elan.c

index 415aaef..233e4a8 100644

--- a/libfprint/drivers/elan.c

+++ b/libfprint/drivers/elan.c

@@ -73,18 +73,18 @@ struct _FpiDeviceElan

   /* end commands */

   /* state */

-  gboolean           deactivating;

-  FpImageDeviceState dev_state;

-  FpImageDeviceState dev_state_next;

-  unsigned char     *last_read;

-  unsigned char      calib_atts_left;

-  unsigned char      calib_status;

-  unsigned short    *background;

-  unsigned char      frame_width;

-  unsigned char      frame_height;

-  unsigned char      raw_frame_height;

-  int                num_frames;

-  GSList            *frames;

+  gboolean            deactivating;

+  FpiImageDeviceState dev_state;

+  FpiImageDeviceState dev_state_next;

+  unsigned char      *last_read;

+  unsigned char       calib_atts_left;

+  unsigned char       calib_status;

+  unsigned short     *background;

+  unsigned char       frame_width;

+  unsigned char       frame_height;

+  unsigned char       raw_frame_height;

+  int                 num_frames;

+  GSList             *frames;

   /* end state */

 };

 G_DECLARE_FINAL_TYPE (FpiDeviceElan, fpi_device_elan, FPI, DEVICE_ELAN,

@@ -481,7 +481,7 @@ stop_capture_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)

   /* The device is inactive at this point. */

-  self->dev_state = FP_IMAGE_DEVICE_STATE_INACTIVE;

+  self->dev_state = FPI_IMAGE_DEVICE_STATE_INACTIVE;

   if (self->deactivating)

     {

@@ -538,7 +538,7 @@ capture_run_state (FpiSsm *ssm, FpDevice *dev)

       break;

     case CAPTURE_READ_DATA:

-      self->dev_state = FP_IMAGE_DEVICE_STATE_CAPTURE;

+      self->dev_state = FPI_IMAGE_DEVICE_STATE_CAPTURE;

       /* 0x55 - finger present

        * 0xff - device not calibrated (probably) */

@@ -773,7 +773,7 @@ calibrate_complete (FpiSsm *ssm, FpDevice *dev, GError *error)

   if (error)

     {

-      self->dev_state = FP_IMAGE_DEVICE_STATE_INACTIVE;

+      self->dev_state = FPI_IMAGE_DEVICE_STATE_INACTIVE;

       fpi_image_device_session_error (FP_IMAGE_DEVICE (dev), error);

     }

   else

@@ -951,7 +951,7 @@ elan_change_state (FpImageDevice *idev)

 {

   FpDevice *dev = FP_DEVICE (idev);

   FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);

-  FpImageDeviceState next_state = self->dev_state_next;

+  FpiImageDeviceState next_state = self->dev_state_next;

   if (self->dev_state == next_state)

     {

@@ -965,18 +965,18 @@ elan_change_state (FpImageDevice *idev)

   switch (next_state)

     {

-    case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:

+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:

       /* activation completed or another enroll stage started */

-      self->dev_state = FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON;

+      self->dev_state = FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON;

       elan_calibrate (dev);

       break;

-    case FP_IMAGE_DEVICE_STATE_CAPTURE:

+    case FPI_IMAGE_DEVICE_STATE_CAPTURE:

       /* not used */

       break;

-    case FP_IMAGE_DEVICE_STATE_INACTIVE:

-    case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:

+    case FPI_IMAGE_DEVICE_STATE_INACTIVE:

+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:

       elan_stop_capture (dev);

       break;

     }

@@ -991,7 +991,7 @@ elan_change_state_async (FpDevice *dev,

 }

 static void

-dev_change_state (FpImageDevice *dev, FpImageDeviceState state)

+dev_change_state (FpImageDevice *dev, FpiImageDeviceState state)

 {

   FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);

   GSource *timeout;

@@ -999,17 +999,17 @@ dev_change_state (FpImageDevice *dev, FpImageDeviceState state)

   G_DEBUG_HERE ();

   /* Inactive and await finger off are equivalent for the elan driver. */

-  if (state == FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)

-    state = FP_IMAGE_DEVICE_STATE_INACTIVE;

+  if (state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)

+    state = FPI_IMAGE_DEVICE_STATE_INACTIVE;

   if (self->dev_state_next == state)

     fp_dbg ("change to state %d already queued", state);

   switch (state)

     {

-    case FP_IMAGE_DEVICE_STATE_INACTIVE:

-    case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:

-    case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF: {

+    case FPI_IMAGE_DEVICE_STATE_INACTIVE:

+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:

+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF: {

         char *name;

         /* schedule state change instead of calling it directly to allow all actions

@@ -1026,7 +1026,7 @@ dev_change_state (FpImageDevice *dev, FpImageDeviceState state)

         break;

       }

-    case FP_IMAGE_DEVICE_STATE_CAPTURE:

+    case FPI_IMAGE_DEVICE_STATE_CAPTURE:

       /* TODO MAYBE: split capture ssm into smaller ssms and use this state */

       self->dev_state = state;

       self->dev_state_next = state;

@@ -1044,7 +1044,7 @@ dev_deactivate (FpImageDevice *dev)

   G_DEBUG_HERE ();

-  if (self->dev_state == FP_IMAGE_DEVICE_STATE_INACTIVE)

+  if (self->dev_state == FPI_IMAGE_DEVICE_STATE_INACTIVE)

     {

       /* The device is inactive already, complete the operation immediately. */

       fpi_image_device_deactivate_complete (dev, NULL);

@@ -1055,7 +1055,7 @@ dev_deactivate (FpImageDevice *dev)

        * need to signal back deactivation) and then ensure we will change

        * to the inactive state eventually. */

       self->deactivating = TRUE;

-      dev_change_state (dev, FP_IMAGE_DEVICE_STATE_INACTIVE);

+      dev_change_state (dev, FPI_IMAGE_DEVICE_STATE_INACTIVE);

     }

 }

diff --git a/libfprint/drivers/elan.h b/libfprint/drivers/elan.h

index 1fdd820..2b1c089 100644

--- a/libfprint/drivers/elan.h

+++ b/libfprint/drivers/elan.h

@@ -221,5 +221,5 @@ static void elan_cmd_read (FpiSsm   *ssm,

 static void elan_calibrate (FpDevice *dev);

 static void elan_capture (FpDevice *dev);

-static void dev_change_state (FpImageDevice     *dev,

-                              FpImageDeviceState state);

+static void dev_change_state (FpImageDevice      *dev,

+                              FpiImageDeviceState state);

diff --git a/libfprint/drivers/synaptics/synaptics.c b/libfprint/drivers/synaptics/synaptics.c

index 97d9d21..af4a2fd 100644

--- a/libfprint/drivers/synaptics/synaptics.c

+++ b/libfprint/drivers/synaptics/synaptics.c

@@ -517,7 +517,7 @@ list_msg_cb (FpiDeviceSynaptics *self,

                                 get_enroll_templates_resp->templates[n].finger_id,

                                 uid);

-          fpi_print_set_type (print, FP_PRINT_RAW);

+          fpi_print_set_type (print, FPI_PRINT_RAW);

           fpi_print_set_device_stored (print, TRUE);

           g_object_set (print, "fp-data", data, NULL);

           g_object_set (print, "description", get_enroll_templates_resp->templates[n].user_id, NULL);

@@ -856,7 +856,7 @@ enroll (FpDevice *device)

                         finger,

                         uid);

-  fpi_print_set_type (print, FP_PRINT_RAW);

+  fpi_print_set_type (print, FPI_PRINT_RAW);

   fpi_print_set_device_stored (print, TRUE);

   g_object_set (print, "fp-data", data, NULL);

   g_object_set (print, "description", user_id, NULL);

diff --git a/libfprint/drivers/uru4000.c b/libfprint/drivers/uru4000.c

index 5128a12..b86c6c8 100644

--- a/libfprint/drivers/uru4000.c

+++ b/libfprint/drivers/uru4000.c

@@ -122,7 +122,7 @@ struct _FpiDeviceUru4000

   const struct uru4k_dev_profile *profile;

   uint8_t                         interface;

-  FpImageDeviceState              activate_state;

+  FpiImageDeviceState             activate_state;

   unsigned char                   last_reg_rd[16];

   unsigned char                   last_hwstat;

@@ -408,16 +408,16 @@ change_state_write_reg_cb (FpiUsbTransfer *transfer,

 }

 static void

-dev_change_state (FpImageDevice *dev, FpImageDeviceState state)

+dev_change_state (FpImageDevice *dev, FpiImageDeviceState state)

 {

   FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (dev);

   switch (state)

     {

-    case FP_IMAGE_DEVICE_STATE_INACTIVE:

-    case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:

-    case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:

-    case FP_IMAGE_DEVICE_STATE_CAPTURE:

+    case FPI_IMAGE_DEVICE_STATE_INACTIVE:

+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:

+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:

+    case FPI_IMAGE_DEVICE_STATE_CAPTURE:

       break;

     default:

@@ -773,7 +773,7 @@ imaging_run_state (FpiSsm *ssm, FpDevice *_dev)

         fpimg->flags |= FPI_IMAGE_V_FLIPPED | FPI_IMAGE_H_FLIPPED;

       fpi_image_device_image_captured (dev, fpimg);

-      if (self->activate_state == FP_IMAGE_DEVICE_STATE_CAPTURE)

+      if (self->activate_state == FPI_IMAGE_DEVICE_STATE_CAPTURE)

         fpi_ssm_jump_to_state (ssm, IMAGING_CAPTURE);

       else

         fpi_ssm_mark_completed (ssm);

@@ -1176,7 +1176,7 @@ deactivate_write_reg_cb (FpiUsbTransfer *transfer, FpDevice *dev,

 static void

 dev_deactivate (FpImageDevice *dev)

 {

-  dev_change_state (dev, FP_IMAGE_DEVICE_STATE_INACTIVE);

+  dev_change_state (dev, FPI_IMAGE_DEVICE_STATE_INACTIVE);

 }

 static void

@@ -1187,7 +1187,7 @@ execute_state_change (FpImageDevice *dev)

   switch (self->activate_state)

     {

-    case FP_IMAGE_DEVICE_STATE_INACTIVE:

+    case FPI_IMAGE_DEVICE_STATE_INACTIVE:

       fp_dbg ("deactivating");

       self->irq_cb = NULL;

       self->irq_cb_data = NULL;

@@ -1195,7 +1195,7 @@ execute_state_change (FpImageDevice *dev)

                  deactivate_write_reg_cb, NULL);

       break;

-    case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:

+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:

       fp_dbg ("wait finger on");

       if (!IRQ_HANDLER_IS_RUNNING (self))

         {

@@ -1209,7 +1209,7 @@ execute_state_change (FpImageDevice *dev)

                  change_state_write_reg_cb, NULL);

       break;

-    case FP_IMAGE_DEVICE_STATE_CAPTURE:

+    case FPI_IMAGE_DEVICE_STATE_CAPTURE:

       fp_dbg ("starting capture");

       self->irq_cb = NULL;

@@ -1229,7 +1229,7 @@ execute_state_change (FpImageDevice *dev)

                  change_state_write_reg_cb, NULL);

       break;

-    case FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:

+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:

       fp_dbg ("await finger off");

       if (!IRQ_HANDLER_IS_RUNNING (self))

         {

diff --git a/libfprint/fp-device-private.h b/libfprint/fp-device-private.h

index 65fb1cb..1a350fe 100644

--- a/libfprint/fp-device-private.h

+++ b/libfprint/fp-device-private.h

@@ -41,7 +41,7 @@ typedef struct

   GSList      *sources;

   /* We always make sure that only one task is run at a time. */

-  FpDeviceAction      current_action;

+  FpiDeviceAction     current_action;

   GTask              *current_task;

   GAsyncReadyCallback current_user_cb;

   gulong              current_cancellable_id;

diff --git a/libfprint/fp-device.c b/libfprint/fp-device.c

index 3ac3a1c..8041a86 100644

--- a/libfprint/fp-device.c

+++ b/libfprint/fp-device.c

@@ -81,7 +81,7 @@ fp_device_cancel_in_idle_cb (gpointer user_data)

   FpDevicePrivate *priv = fp_device_get_instance_private (self);

   g_assert (cls->cancel);

-  g_assert (priv->current_action != FP_DEVICE_ACTION_NONE);

+  g_assert (priv->current_action != FPI_DEVICE_ACTION_NONE);

   g_debug ("Idle cancelling on ongoing operation!");

@@ -148,7 +148,7 @@ fp_device_finalize (GObject *object)

   FpDevice *self = (FpDevice *) object;

   FpDevicePrivate *priv = fp_device_get_instance_private (self);

-  g_assert (priv->current_action == FP_DEVICE_ACTION_NONE);

+  g_assert (priv->current_action == FPI_DEVICE_ACTION_NONE);

   g_assert (priv->current_task == NULL);

   if (priv->is_open)

     g_warning ("User destroyed open device! Not cleaning up properly!");

@@ -268,7 +268,7 @@ fp_device_async_initable_init_async (GAsyncInitable     *initable,

       return;

     }

-  priv->current_action = FP_DEVICE_ACTION_PROBE;

+  priv->current_action = FPI_DEVICE_ACTION_PROBE;

   priv->current_task = g_steal_pointer (&task);

   maybe_cancel_on_cancelled (self, cancellable);

@@ -584,7 +584,7 @@ fp_device_open (FpDevice           *device,

       return;

     }

-  priv->current_action = FP_DEVICE_ACTION_OPEN;

+  priv->current_action = FPI_DEVICE_ACTION_OPEN;

   priv->current_task = g_steal_pointer (&task);

   maybe_cancel_on_cancelled (device, cancellable);

@@ -648,7 +648,7 @@ fp_device_close (FpDevice           *device,

       return;

     }

-  priv->current_action = FP_DEVICE_ACTION_CLOSE;

+  priv->current_action = FPI_DEVICE_ACTION_CLOSE;

   priv->current_task = g_steal_pointer (&task);

   maybe_cancel_on_cancelled (device, cancellable);

@@ -709,7 +709,7 @@ fp_device_enroll (FpDevice           *device,

   g_autoptr(GTask) task = NULL;

   FpDevicePrivate *priv = fp_device_get_instance_private (device);

   FpEnrollData *data;

-  FpPrintType print_type;

+  FpiPrintType print_type;

   task = g_task_new (device, cancellable, callback, user_data);

   if (g_task_return_error_if_cancelled (task))

@@ -738,7 +738,7 @@ fp_device_enroll (FpDevice           *device,

     }

   g_object_get (template_print, "fp-type", &print_type, NULL);

-  if (print_type != FP_PRINT_UNDEFINED)

+  if (print_type != FPI_PRINT_UNDEFINED)

     {

       g_warning ("Passed print template must be newly created and blank!");

       g_task_return_error (task,

@@ -746,7 +746,7 @@ fp_device_enroll (FpDevice           *device,

       return;

     }

-  priv->current_action = FP_DEVICE_ACTION_ENROLL;

+  priv->current_action = FPI_DEVICE_ACTION_ENROLL;

   priv->current_task = g_steal_pointer (&task);

   maybe_cancel_on_cancelled (device, cancellable);

@@ -822,7 +822,7 @@ fp_device_verify (FpDevice           *device,

       return;

     }

-  priv->current_action = FP_DEVICE_ACTION_VERIFY;

+  priv->current_action = FPI_DEVICE_ACTION_VERIFY;

   priv->current_task = g_steal_pointer (&task);

   maybe_cancel_on_cancelled (device, cancellable);

@@ -915,7 +915,7 @@ fp_device_identify (FpDevice           *device,

       return;

     }

-  priv->current_action = FP_DEVICE_ACTION_IDENTIFY;

+  priv->current_action = FPI_DEVICE_ACTION_IDENTIFY;

   priv->current_task = g_steal_pointer (&task);

   maybe_cancel_on_cancelled (device, cancellable);

@@ -1008,7 +1008,7 @@ fp_device_capture (FpDevice           *device,

       return;

     }

-  priv->current_action = FP_DEVICE_ACTION_CAPTURE;

+  priv->current_action = FPI_DEVICE_ACTION_CAPTURE;

   priv->current_task = g_steal_pointer (&task);

   maybe_cancel_on_cancelled (device, cancellable);

@@ -1089,7 +1089,7 @@ fp_device_delete_print (FpDevice           *device,

       return;

     }

-  priv->current_action = FP_DEVICE_ACTION_DELETE;

+  priv->current_action = FPI_DEVICE_ACTION_DELETE;

   priv->current_task = g_steal_pointer (&task);

   maybe_cancel_on_cancelled (device, cancellable);

@@ -1159,7 +1159,7 @@ fp_device_list_prints (FpDevice           *device,

       return;

     }

-  priv->current_action = FP_DEVICE_ACTION_LIST;

+  priv->current_action = FPI_DEVICE_ACTION_LIST;

   priv->current_task = g_steal_pointer (&task);

   maybe_cancel_on_cancelled (device, cancellable);

diff --git a/libfprint/fp-image-device-private.h b/libfprint/fp-image-device-private.h

index 01454fd..07a0347 100644

--- a/libfprint/fp-image-device-private.h

+++ b/libfprint/fp-image-device-private.h

@@ -25,17 +25,17 @@

 typedef struct

 {

-  FpImageDeviceState state;

-  gboolean           active;

-  gboolean           cancelling;

+  FpiImageDeviceState state;

+  gboolean            active;

+  gboolean            cancelling;

-  gboolean           enroll_await_on_pending;

-  gint               enroll_stage;

+  gboolean            enroll_await_on_pending;

+  gint                enroll_stage;

-  guint              pending_activation_timeout_id;

-  gboolean           pending_activation_timeout_waiting_finger_off;

+  guint               pending_activation_timeout_id;

+  gboolean            pending_activation_timeout_waiting_finger_off;

-  gint               bz3_threshold;

+  gint                bz3_threshold;

 } FpImageDevicePrivate;

diff --git a/libfprint/fp-image-device.c b/libfprint/fp-image-device.c

index 24d324d..9e6c375 100644

--- a/libfprint/fp-image-device.c

+++ b/libfprint/fp-image-device.c

@@ -106,7 +106,7 @@ fp_image_device_close (FpDevice *device)

   if (!priv->active)

     cls->img_close (self);

-  else if (priv->state != FP_IMAGE_DEVICE_STATE_INACTIVE)

+  else if (priv->state != FPI_IMAGE_DEVICE_STATE_INACTIVE)

     fpi_image_device_deactivate (self);

 }

@@ -115,16 +115,16 @@ fp_image_device_cancel_action (FpDevice *device)

 {

   FpImageDevice *self = FP_IMAGE_DEVICE (device);

   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);

-  FpDeviceAction action;

+  FpiDeviceAction action;

   action = fpi_device_get_current_action (device);

   /* We can only cancel capture operations, in that case, deactivate and return

    * an error immediately. */

-  if (action == FP_DEVICE_ACTION_ENROLL ||

-      action == FP_DEVICE_ACTION_VERIFY ||

-      action == FP_DEVICE_ACTION_IDENTIFY ||

-      action == FP_DEVICE_ACTION_CAPTURE)

+  if (action == FPI_DEVICE_ACTION_ENROLL ||

+      action == FPI_DEVICE_ACTION_VERIFY ||

+      action == FPI_DEVICE_ACTION_IDENTIFY ||

+      action == FPI_DEVICE_ACTION_CAPTURE)

     {

       priv->cancelling = TRUE;

       fpi_image_device_deactivate (self);

@@ -143,14 +143,14 @@ fp_image_device_start_capture_action (FpDevice *device)

 {

   FpImageDevice *self = FP_IMAGE_DEVICE (device);

   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);

-  FpDeviceAction action;

+  FpiDeviceAction action;

   /* There is just one action that we cannot support out

    * of the box, which is a capture without first waiting

    * for a finger to be on the device.

    */

   action = fpi_device_get_current_action (device);

-  if (action == FP_DEVICE_ACTION_CAPTURE)

+  if (action == FPI_DEVICE_ACTION_CAPTURE)

     {

       gboolean wait_for_finger;

@@ -162,12 +162,12 @@ fp_image_device_start_capture_action (FpDevice *device)

           return;

         }

     }

-  else if (action == FP_DEVICE_ACTION_ENROLL)

+  else if (action == FPI_DEVICE_ACTION_ENROLL)

     {

       FpPrint *enroll_print = NULL;

       fpi_device_get_enroll_data (device, &enroll_print);

-      fpi_print_set_type (enroll_print, FP_PRINT_NBIS);

+      fpi_print_set_type (enroll_print, FPI_PRINT_NBIS);

     }

   priv->enroll_stage = 0;

@@ -178,14 +178,14 @@ fp_image_device_start_capture_action (FpDevice *device)

    * error (which will usually say that the user should remove the

    * finger).

    */

-  if (priv->state != FP_IMAGE_DEVICE_STATE_INACTIVE || priv->active)

+  if (priv->state != FPI_IMAGE_DEVICE_STATE_INACTIVE || priv->active)

     {

       g_debug ("Got a new request while the device was still active");

       g_assert (priv->pending_activation_timeout_id == 0);

       priv->pending_activation_timeout_id =

         g_timeout_add (100, pending_activation_timeout, device);

-      if (priv->state == FP_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)

+      if (priv->state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)

         priv->pending_activation_timeout_waiting_finger_off = TRUE;

       else

         priv->pending_activation_timeout_waiting_finger_off = FALSE;

@@ -271,8 +271,8 @@ fp_image_device_class_init (FpImageDeviceClass *klass)

     g_param_spec_enum ("fp-image-device-state",

                        "Image Device State",

                        "Private: The state of the image device",

-                       FP_TYPE_IMAGE_DEVICE_STATE,

-                       FP_IMAGE_DEVICE_STATE_INACTIVE,

+                       FPI_TYPE_IMAGE_DEVICE_STATE,

+                       FPI_IMAGE_DEVICE_STATE_INACTIVE,

                        G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);

   signals[FPI_STATE_CHANGED] =

@@ -281,7 +281,7 @@ fp_image_device_class_init (FpImageDeviceClass *klass)

                   G_SIGNAL_RUN_FIRST,

                   G_STRUCT_OFFSET (FpImageDeviceClass, change_state),

                   NULL, NULL, NULL,

-                  G_TYPE_NONE, 1, FP_TYPE_IMAGE_DEVICE_STATE);

+                  G_TYPE_NONE, 1, FPI_TYPE_IMAGE_DEVICE_STATE);

   g_object_class_install_properties (object_class, N_PROPS, properties);

 }

diff --git a/libfprint/fp-print-private.h b/libfprint/fp-print-private.h

index f5822b3..6d44700 100644

--- a/libfprint/fp-print-private.h

+++ b/libfprint/fp-print-private.h

@@ -27,7 +27,7 @@ struct _FpPrint

 {

   GInitiallyUnowned parent_instance;

-  FpPrintType       type;

+  FpiPrintType      type;

   gchar            *driver;

   gchar            *device_id;

diff --git a/libfprint/fp-print.c b/libfprint/fp-print.c

index 30fdf1a..dd45b95 100644

--- a/libfprint/fp-print.c

+++ b/libfprint/fp-print.c

@@ -272,8 +272,8 @@ fp_print_class_init (FpPrintClass *klass)

     g_param_spec_enum ("fp-type",

                        "Type",

                        "Private: The type of the print data",

-                       FP_TYPE_PRINT_TYPE,

-                       FP_PRINT_RAW,

+                       FPI_TYPE_PRINT_TYPE,

+                       FPI_PRINT_RAW,

                        G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);

   properties[PROP_FPI_DATA] =

@@ -555,8 +555,8 @@ fp_print_equal (FpPrint *self, FpPrint *other)

 {

   g_return_val_if_fail (FP_IS_PRINT (self), FALSE);

   g_return_val_if_fail (FP_IS_PRINT (other), FALSE);

-  g_return_val_if_fail (self->type != FP_PRINT_UNDEFINED, FALSE);

-  g_return_val_if_fail (other->type != FP_PRINT_UNDEFINED, FALSE);

+  g_return_val_if_fail (self->type != FPI_PRINT_UNDEFINED, FALSE);

+  g_return_val_if_fail (other->type != FPI_PRINT_UNDEFINED, FALSE);

   if (self->type != other->type)

     return FALSE;

@@ -567,11 +567,11 @@ fp_print_equal (FpPrint *self, FpPrint *other)

   if (g_strcmp0 (self->device_id, other->device_id))

     return FALSE;

-  if (self->type == FP_PRINT_RAW)

+  if (self->type == FPI_PRINT_RAW)

     {

       return g_variant_equal (self->data, other->data);

     }

-  else if (self->type == FP_PRINT_NBIS)

+  else if (self->type == FPI_PRINT_NBIS)

     {

       gint i;

@@ -595,7 +595,7 @@ fp_print_equal (FpPrint *self, FpPrint *other)

     }

 }

-#define FP_PRINT_VARIANT_TYPE G_VARIANT_TYPE ("(issbymsmsia{sv}v)")

+#define FPI_PRINT_VARIANT_TYPE G_VARIANT_TYPE ("(issbymsmsia{sv}v)")

 G_STATIC_ASSERT (sizeof (((struct xyt_struct *) NULL)->xcol[0]) == 4);

@@ -618,7 +618,7 @@ fp_print_serialize (FpPrint *print,

                     GError **error)

 {

   g_autoptr(GVariant) result = NULL;

-  GVariantBuilder builder = G_VARIANT_BUILDER_INIT (FP_PRINT_VARIANT_TYPE);

+  GVariantBuilder builder = G_VARIANT_BUILDER_INIT (FPI_PRINT_VARIANT_TYPE);

   gsize len;

   g_assert (data);

@@ -643,7 +643,7 @@ fp_print_serialize (FpPrint *print,

   g_variant_builder_close (&builder);

   /* Insert NBIS print data for type NBIS, otherwise the GVariant directly */

-  if (print->type == FP_PRINT_NBIS)

+  if (print->type == FPI_PRINT_NBIS)

     {

       GVariantBuilder nested = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE ("(a(aiaiai))"));

       gint i;

@@ -745,7 +745,7 @@ fp_print_deserialize (const guchar *data,

   g_autofree gchar *username = NULL;

   g_autofree gchar *description = NULL;

   gint julian_date;

-  FpPrintType type;

+  FpiPrintType type;

   const gchar *driver;

   const gchar *device_id;

   gboolean device_stored;

@@ -766,7 +766,7 @@ fp_print_deserialize (const guchar *data,

    * longer. */

   aligned_data = g_malloc (length - 3);

   memcpy (aligned_data, data + 3, length - 3);

-  raw_value = g_variant_new_from_data (FP_PRINT_VARIANT_TYPE,

+  raw_value = g_variant_new_from_data (FPI_PRINT_VARIANT_TYPE,