From 3b368f67de150199ba2dfb083ab22e7fd2e4204f Mon Sep 17 00:00:00 2001

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

Date: Tue, 10 Dec 2019 20:24:04 +0100

Subject: [PATCH 105/181] fp-device: Move fpi code into its own unit that can

 be compiled a part

In order to be able to test the private device code (used by drivers) we

need to have that split a part in a different .c file so that we can compile

it alone and link with it both the shared library and the test executables.

Redefine fp_device_get_instance_private for private usage, not to move

the private struct as part of FpDevice.

---

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

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

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

 libfprint/meson.build         |    1 +

 4 files changed, 1245 insertions(+), 1184 deletions(-)

 create mode 100644 libfprint/fp-device-private.h

 create mode 100644 libfprint/fpi-device.c

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

new file mode 100644

index 0000000..65fb1cb

--- /dev/null

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

@@ -0,0 +1,65 @@

+/*

+ * FpDevice - A fingerprint reader device

+ * Copyright (C) 2019 Benjamin Berg <bberg@redhat.com>

+ * Copyright (C) 2019 Marco Trevisan <marco.trevisan@canonical.com>

+ *

+ * This library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * This library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with this library; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#pragma once

+

+#include "fpi-device.h"

+

+typedef struct

+{

+  FpDeviceType type;

+

+  GUsbDevice  *usb_device;

+  const gchar *virtual_env;

+

+  gboolean     is_open;

+

+  gchar       *device_id;

+  gchar       *device_name;

+  FpScanType   scan_type;

+

+  guint64      driver_data;

+

+  gint         nr_enroll_stages;

+  GSList      *sources;

+

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

+  FpDeviceAction      current_action;

+  GTask              *current_task;

+  GAsyncReadyCallback current_user_cb;

+  gulong              current_cancellable_id;

+  GSource            *current_idle_cancel_source;

+  GSource            *current_task_idle_return_source;

+

+  /* State for tasks */

+  gboolean wait_for_finger;

+} FpDevicePrivate;

+

+

+typedef struct

+{

+  FpPrint         *print;

+

+  FpEnrollProgress enroll_progress_cb;

+  gpointer         enroll_progress_data;

+  GDestroyNotify   enroll_progress_destroy;

+} FpEnrollData;

+

+void enroll_data_free (FpEnrollData *enroll_data);

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

index 91a3aae..c49e5a9 100644

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

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

@@ -21,17 +21,7 @@

 #define FP_COMPONENT "device"

 #include "fpi-log.h"

-#include "fpi-device.h"

-

-/**

- * SECTION: fp-device

- * @title: FpDevice

- * @short_description: Fingerprint device handling

- *

- * The #FpDevice object allows you to interact with fingerprint readers.

- * Befor doing any other operation you need to fp_device_open() the device

- * and after you are done you need to fp_device_close() it again.

- */

+#include "fp-device-private.h"

 /**

  * SECTION: fpi-device

@@ -46,36 +36,6 @@

  * Also see the public #FpDevice routines.

  */

-typedef struct

-{

-  FpDeviceType type;

-

-  GUsbDevice  *usb_device;

-  const gchar *virtual_env;

-

-  gboolean   is_open;

-

-  gchar     *device_id;

-  gchar     *device_name;

-  FpScanType scan_type;

-

-  guint64    driver_data;

-

-  gint       nr_enroll_stages;

-  GSList    *sources;

-

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

-  FpDeviceAction      current_action;

-  GTask              *current_task;

-  GAsyncReadyCallback current_user_cb;

-  gulong              current_cancellable_id;

-  GSource            *current_idle_cancel_source;

-  GSource            *current_task_idle_return_source;

-

-  /* State for tasks */

-  gboolean wait_for_finger;

-} FpDevicePrivate;

-

 static void fp_device_async_initable_iface_init (GAsyncInitableIface *iface);

 G_DEFINE_TYPE_EXTENDED (FpDevice, fp_device, G_TYPE_OBJECT, G_TYPE_FLAG_ABSTRACT,

@@ -99,27 +59,6 @@ enum {

 static GParamSpec *properties[N_PROPS];

-typedef struct

-{

-  FpPrint         *print;

-

-  FpEnrollProgress enroll_progress_cb;

-  gpointer         enroll_progress_data;

-  GDestroyNotify   enroll_progress_destroy;

-} FpEnrollData;

-

-static void

-enroll_data_free (gpointer free_data)

-{

-  FpEnrollData *data = free_data;

-

-  if (data->enroll_progress_destroy)

-    data->enroll_progress_destroy (data->enroll_progress_data);

-  data->enroll_progress_data = NULL;

-  g_clear_object (&data->print);

-  g_free (data);

-}

-

 /**

  * fp_device_retry_quark:

  *

@@ -134,150 +73,6 @@ G_DEFINE_QUARK (fp - device - retry - quark, fp_device_retry)

  **/

 G_DEFINE_QUARK (fp - device - error - quark, fp_device_error)

-/**

- * fpi_device_retry_new:

- * @error: The #FpDeviceRetry error value describing the issue

- *

- * Create a new retry error code for use with fpi_device_verify_complete()

- * and similar calls.

- */

-GError *

-fpi_device_retry_new (FpDeviceRetry error)

-{

-  const gchar *msg;

-

-  switch (error)

-    {

-    case FP_DEVICE_RETRY_GENERAL:

-      msg = "Please try again.";

-      break;

-

-    case FP_DEVICE_RETRY_TOO_SHORT:

-      msg = "The swipe was too short, please try again.";

-      break;

-

-    case FP_DEVICE_RETRY_CENTER_FINGER:

-      msg = "The finger was not centered properly, please try again.";

-      break;

-

-    case FP_DEVICE_RETRY_REMOVE_FINGER:

-      msg = "Please try again after removing the finger first.";

-      break;

-

-    default:

-      g_warning ("Unsupported error, returning general error instead!");

-      error = FP_DEVICE_RETRY_GENERAL;

-      msg = "Please try again.";

-    }

-

-  return g_error_new_literal (FP_DEVICE_RETRY, error, msg);

-}

-

-/**

- * fpi_device_error_new:

- * @error: The #FpDeviceRetry error value describing the issue

- *

- * Create a new error code for use with fpi_device_verify_complete() and

- * similar calls.

- */

-GError *

-fpi_device_error_new (FpDeviceError error)

-{

-  const gchar *msg;

-

-  switch (error)

-    {

-    case FP_DEVICE_ERROR_GENERAL:

-      msg = "An unspecified error occured!";

-      break;

-

-    case FP_DEVICE_ERROR_NOT_SUPPORTED:

-      msg = "The operation is not supported on this device!";

-      break;

-

-    case FP_DEVICE_ERROR_NOT_OPEN:

-      msg = "The device needs to be opened first!";

-      break;

-

-    case FP_DEVICE_ERROR_ALREADY_OPEN:

-      msg = "The device has already been opened!";

-      break;

-

-    case FP_DEVICE_ERROR_BUSY:

-      msg = "The device is still busy with another operation, please try again later.";

-      break;

-

-    case FP_DEVICE_ERROR_PROTO:

-      msg = "The driver encountered a protocol error with the device.";

-      break;

-

-    case FP_DEVICE_ERROR_DATA_INVALID:

-      msg = "Passed (print) data is not valid.";

-      break;

-

-    case FP_DEVICE_ERROR_DATA_FULL:

-      msg = "On device storage space is full.";

-      break;

-

-    case FP_DEVICE_ERROR_DATA_NOT_FOUND:

-      msg = "Print was not found on the devices storage.";

-      break;

-

-    default:

-      g_warning ("Unsupported error, returning general error instead!");

-      error = FP_DEVICE_ERROR_GENERAL;

-      msg = "An unspecified error occured!";

-    }

-

-  return g_error_new_literal (FP_DEVICE_ERROR, error, msg);

-}

-

-/**

- * fpi_device_retry_new_msg:

- * @error: The #FpDeviceRetry error value describing the issue

- * @msg: Custom message to use

- *

- * Create a new retry error code for use with fpi_device_verify_complete()

- * and similar calls.

- */

-GError *

-fpi_device_retry_new_msg (FpDeviceRetry device_error,

-                          const gchar  *msg,

-                          ...)

-{

-  GError *error;

-  va_list args;

-

-  va_start (args, msg);

-  error = g_error_new_valist (FP_DEVICE_RETRY, device_error, msg, args);

-  va_end (args);

-

-  return error;

-}

-

-/**

- * fpi_device_error_new_msg:

- * @error: The #FpDeviceRetry error value describing the issue

- * @msg: Custom message to use

- *

- * Create a new error code for use with fpi_device_verify_complete()

- * and similar calls.

- */

-GError *

-fpi_device_error_new_msg (FpDeviceError device_error,

-                          const gchar  *msg,

-                          ...)

-{

-  GError *error;

-  va_list args;

-

-  va_start (args, msg);

-  error = g_error_new_valist (FP_DEVICE_ERROR, device_error, msg, args);

-  va_end (args);

-

-  return error;

-}

-

 static gboolean

 fp_device_cancel_in_idle_cb (gpointer user_data)

 {

@@ -330,21 +125,6 @@ maybe_cancel_on_cancelled (FpDevice     *device,

                                                         NULL);

 }

-static void

-clear_device_cancel_action (FpDevice *device)

-{

-  FpDevicePrivate *priv = fp_device_get_instance_private (device);

-

-  g_clear_pointer (&priv->current_idle_cancel_source, g_source_destroy);

-

-  if (priv->current_cancellable_id)

-    {

-      g_cancellable_disconnect (g_task_get_cancellable (priv->current_task),

-                                priv->current_cancellable_id);

-      priv->current_cancellable_id = 0;

-    }

-}

-

 static void

 fp_device_constructed (GObject *object)

 {

@@ -976,7 +756,7 @@ fp_device_enroll (FpDevice           *device,

   data->enroll_progress_data = progress_data;

   // Attach the progress data as task data so that it is destroyed

-  g_task_set_task_data (priv->current_task, data, enroll_data_free);

+  g_task_set_task_data (priv->current_task, data, (GDestroyNotify) enroll_data_free);

   FP_DEVICE_GET_CLASS (device)->enroll (device);

 }

@@ -1406,968 +1186,6 @@ fp_device_list_prints_finish (FpDevice     *device,

   return g_task_propagate_pointer (G_TASK (result), error);

 }

-typedef struct

-{

-  GSource   source;

-  FpDevice *device;

-} FpDeviceTimeoutSource;

-

-static void

-timeout_finalize (GSource *source)

-{

-  FpDeviceTimeoutSource *timeout_source = (FpDeviceTimeoutSource *) source;

-  FpDevicePrivate *priv;

-

-  priv = fp_device_get_instance_private (timeout_source->device);

-  priv->sources = g_slist_remove (priv->sources, source);

-}

-

-static gboolean

-timeout_dispatch (GSource *source, GSourceFunc gsource_func, gpointer user_data)

-{

-  FpDeviceTimeoutSource *timeout_source = (FpDeviceTimeoutSource *) source;

-  FpTimeoutFunc callback = (FpTimeoutFunc) gsource_func;

-

-  callback (timeout_source->device, user_data);

-

-  return G_SOURCE_REMOVE;

-}

-

-static GSourceFuncs timeout_funcs = {

-  NULL, /* prepare */

-  NULL, /* check */

-  timeout_dispatch,

-  timeout_finalize,

-  NULL, NULL

-};

-

-/* Private API functions */

-

-/**

- * fpi_device_set_nr_enroll_stages:

- * @device: The #FpDevice

- * @enroll_stages: The number of enroll stages

- *

- * Updates the reported number of enroll stages that the device needs.

- * If all supported devices have the same number of stages, then the

- * value can simply be set in the class.

- */

-void

-fpi_device_set_nr_enroll_stages (FpDevice *device,

-                                 gint      enroll_stages)

-{

-  FpDevicePrivate *priv = fp_device_get_instance_private (device);

-

-  g_return_if_fail (FP_IS_DEVICE (device));

-

-  priv->nr_enroll_stages = enroll_stages;

-  g_object_notify_by_pspec (G_OBJECT (device), properties[PROP_NR_ENROLL_STAGES]);

-}

-

-/**

- * fpi_device_set_scan_type:

- * @device: The #FpDevice

- * @scan_type: The scan type of the device

- *

- * Updates the the scan type of the device from the default.

- * If all supported devices have the same scan type, then the

- * value can simply be set in the class.

- */

-void

-fpi_device_set_scan_type (FpDevice  *device,

-                          FpScanType scan_type)

-{

-  FpDevicePrivate *priv = fp_device_get_instance_private (device);

-

-  g_return_if_fail (FP_IS_DEVICE (device));

-

-  priv->scan_type = scan_type;

-  g_object_notify_by_pspec (G_OBJECT (device), properties[PROP_SCAN_TYPE]);

-}

-

-/**

- * fpi_device_add_timeout:

- * @device: The #FpDevice

- * @interval: The interval in milliseconds

- * @func: The #FpTimeoutFunc to call on timeout

- * @user_data: (nullable): User data to pass to the callback

- * @destroy_notify: (nullable): #GDestroyNotify for @user_data

- *

- * Register a timeout to run. Drivers should always make sure that timers are

- * cancelled when appropriate.

- *

- * Returns: (transfer none): A newly created and attached #GSource

- */

-GSource *

-fpi_device_add_timeout (FpDevice      *device,

-                        gint           interval,

-                        FpTimeoutFunc  func,

-                        gpointer       user_data,

-                        GDestroyNotify destroy_notify)

-{

-  FpDevicePrivate *priv = fp_device_get_instance_private (device);

-  FpDeviceTimeoutSource *source;

-

-  source = (FpDeviceTimeoutSource *) g_source_new (&timeout_funcs,

-                                                   sizeof (FpDeviceTimeoutSource));

-  source->device = device;

-

-  g_source_attach (&source->source, NULL);

-  g_source_set_callback (&source->source, (GSourceFunc) func, user_data, destroy_notify);

-  g_source_set_ready_time (&source->source,

-                           g_source_get_time (&source->source) + interval * (guint64) 1000);

-  priv->sources = g_slist_prepend (priv->sources, source);

-  g_source_unref (&source->source);

-

-  return &source->source;

-}

-

-/**

- * fpi_device_get_usb_device:

- * @device: The #FpDevice

- *

- * Get the #GUsbDevice for this #FpDevice. Only permissible to call if the

- * #FpDevice is of type %FP_DEVICE_TYPE_USB.

- *

- * Returns: The #GUsbDevice

- */

-GUsbDevice *

-fpi_device_get_usb_device (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->type == FP_DEVICE_TYPE_USB, NULL);

-

-  return priv->usb_device;

-}

-

-/**

- * fpi_device_get_virtual_env:

- * @device: The #FpDevice

- *

- * Get the value of the environment variable that caused the virtual #FpDevice to be

- * generated. Only permissible to call if the #FpDevice is of type %FP_DEVICE_TYPE_VIRTUAL.

- *

- * Returns: The value of the environment variable

- */

-const gchar *

-fpi_device_get_virtual_env (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->type == FP_DEVICE_TYPE_VIRTUAL, NULL);

-

-  return priv->virtual_env;

-}

-

-/**

- * fpi_device_get_current_action:

- * @device: The #FpDevice

- *

- * Get the currently ongoing action or %FP_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

- */

-FpDeviceAction

-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);

-

-  return priv->current_action;

-}

-

-/**

- * fpi_device_action_is_cancelled:

- * @device: The #FpDevice

- *

- * Checks whether the current action has been cancelled by the user.

- * This is equivalent to first getting the cancellable using

- * fpi_device_get_cancellable() and then checking whether it has been

- * cancelled (if it is non-NULL).

- *

- * Returns: %TRUE if action should be cancelled

- */

-gboolean

-fpi_device_action_is_cancelled (FpDevice *device)

-{

-  FpDevicePrivate *priv = fp_device_get_instance_private (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);

-

-  cancellable = g_task_get_cancellable (priv->current_task);

-

-  return cancellable ? g_cancellable_is_cancelled (cancellable) : FALSE;

-}

-

-/**

- * fpi_device_get_driver_data:

- * @device: The #FpDevice

- *

- * Returns: The driver data from the #FpIdEntry table entry

- */

-guint64

-fpi_device_get_driver_data (FpDevice *device)

-{

-  FpDevicePrivate *priv = fp_device_get_instance_private (device);

-

-  g_return_val_if_fail (FP_IS_DEVICE (device), 0);

-

-  return priv->driver_data;

-}

-

-/**

- * fpi_device_get_enroll_data:

- * @device: The #FpDevice

- * @print: (out) (transfer none): The user provided template print

- *

- * Get data for enrollment.

- */

-void

-fpi_device_get_enroll_data (FpDevice *device,

-                            FpPrint **print)

-{

-  FpDevicePrivate *priv = fp_device_get_instance_private (device);

-  FpEnrollData *data;

-

-  g_return_if_fail (FP_IS_DEVICE (device));

-  g_return_if_fail (priv->current_action == FP_DEVICE_ACTION_ENROLL);

-

-  data = g_task_get_task_data (priv->current_task);

-  g_assert (data);

-

-  if (print)

-    *print = data->print;

-}

-

-/**

- * fpi_device_get_capture_data:

- * @device: The #FpDevice

- * @wait_for_finger: (out): Whether to wait for finger or not

- *

- * Get data for capture.

- */

-void

-fpi_device_get_capture_data (FpDevice *device,

-                             gboolean *wait_for_finger)

-{

-  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);

-

-  if (wait_for_finger)

-    *wait_for_finger = priv->wait_for_finger;

-}

-

-/**

- * fpi_device_get_verify_data:

- * @device: The #FpDevice

- * @print: (out) (transfer none): The enrolled print

- *

- * Get data for verify.

- */

-void

-fpi_device_get_verify_data (FpDevice *device,

-                            FpPrint **print)

-{

-  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);

-

-  if (print)

-    *print = g_task_get_task_data (priv->current_task);

-}

-

-/**

- * fpi_device_get_identify_data:

- * @device: The #FpDevice

- * @prints: (out) (transfer none) (element-type FpPrint): The gallery of prints

- *

- * Get data for identify.

- */

-void

-fpi_device_get_identify_data (FpDevice   *device,

-                              GPtrArray **prints)

-{

-  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);

-

-  if (prints)

-    *prints = g_task_get_task_data (priv->current_task);

-}

-

-/**

- * fpi_device_get_delete_data:

- * @device: The #FpDevice

- * @print: (out) (transfer none): The print to delete

- *

- * Get data for delete.

- */

-void

-fpi_device_get_delete_data (FpDevice *device,

-                            FpPrint **print)

-{

-  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);

-

-  if (print)

-    *print = g_task_get_task_data (priv->current_task);

-}

-

-/**

- * fpi_device_get_cancellable:

- * @device: The #FpDevice

- *

- * Retrieve the #GCancellable that may cancel the currently ongoing operation. This

- * is primarily useful to pass directly to e.g. fpi_usb_transfer_submit() for cancellable

- * transfers.

- * In many cases the cancel vfunc may be more convenient to react to cancellation in some

- * way.

- *

- * Returns: (transfer none): The #GCancellable for the current action.

- */

-GCancellable *

-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);

-

-  return g_task_get_cancellable (priv->current_task);

-}

-

-/**

- * fpi_device_action_error:

- * @device: The #FpDevice

- * @error: The #GError to return

- *

- * Finish an ongoing action with an error. This is the same as calling