Release 1.90.5

Closes: #341

NEWS

@@ -1,6 +1,37 @@
 This file lists notable changes in each release. For the full history of all
 changes, see ChangeLog.
 
+2020-12-01: v1.90.5 release
+
+The 1.90.4 release caused a major regression, as it included a USB hub in
+UDEV the autosupend rule list.
+
+Highlights:
+ * Remove USB hub from udev autosupend rules
+ * synaptics: Add PID 0x00c9 which is used in some HP laptops
+
+
+2020-11-27: v1.90.4 release
+
+This release contains a number of important bugfixes. On the feature side,
+the USB hotplug support was improved. A lot of drivers received fixes and
+improvements.
+
+Highlights:
+ * Work around GUsb cancellation issue
+ * Redefine internal image device state machine for more robustness
+ * Add public finger-status reporting to FpDevice
+ * Rework device removal API to be convenient (#330)
+ * Enable powersave for unsupported USB devices
+ * Improvements to examples
+ * synaptics: Support identify operation
+ * synaptics: Fix possible crash when the interrupt transfer is resubmitted
+ * synaptics: Add support for PIDs 0x00f9, 0x00fc and 0x00c2
+ * elan: Add PID 0x0c4d to supported device list
+ * aes3k: Fix driver and add CI test (#306)
+ * uru4000: Fix reference counting of image transfer
+ * vfs301: Fix driver and add CI test (#320)
+
 2020-06-08: v1.90.3 release
 
 This release mostly contains support for a number of new match-on-chip

examples/enroll.c

@@ -76,9 +76,14 @@ on_enroll_completed (FpDevice *dev, GAsyncResult *res, void *user_data)
     {
       enroll_data->ret_value = EXIT_SUCCESS;
 
-      if (!fp_device_has_storage (dev))
+      if (fp_device_has_storage (dev))
-        {
+        g_debug ("Device has storage, saving a print reference locally");
-          g_debug ("Device has not storage, saving locally");
+      else
+        g_debug ("Device has not storage, saving print only locally");
+
+      /* Even if the device has storage, it may not be able to save all the
+       * metadata that the print contains, so we can always save a local copy
+       * containing the handle to the device print */
       int r = print_data_save (print, enroll_data->finger);
       if (r < 0)
         {
@@ -86,7 +91,6 @@ on_enroll_completed (FpDevice *dev, GAsyncResult *res, void *user_data)
           enroll_data->ret_value = EXIT_FAILURE;
         }
     }
-    }
   else
     {
       g_warning ("Enroll failed with error %s", error->message);

examples/identify.c

@@ -0,0 +1,319 @@
+/*
+ * Example fingerprint verification program, which verifies the
+ * finger which has been previously enrolled to disk.
+ * Copyright (C) 2020 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
+ */
+
+#define FP_COMPONENT "example-identify"
+
+#include <stdio.h>
+#include <libfprint/fprint.h>
+#include <glib-unix.h>
+
+#include "storage.h"
+#include "utilities.h"
+
+typedef struct _IdentifyData
+{
+  GMainLoop    *loop;
+  GCancellable *cancellable;
+  unsigned int  sigint_handler;
+  int           ret_value;
+} IdentifyData;
+
+static void
+identify_data_free (IdentifyData *identify_data)
+{
+  g_clear_handle_id (&identify_data->sigint_handler, g_source_remove);
+  g_clear_object (&identify_data->cancellable);
+  g_main_loop_unref (identify_data->loop);
+  g_free (identify_data);
+}
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (IdentifyData, identify_data_free)
+
+static void
+on_device_closed (FpDevice *dev, GAsyncResult *res, void *user_data)
+{
+  IdentifyData *identify_data = user_data;
+
+  g_autoptr(GError) error = NULL;
+
+  fp_device_close_finish (dev, res, &error);
+
+  if (error)
+    g_warning ("Failed closing device %s", error->message);
+
+  g_main_loop_quit (identify_data->loop);
+}
+
+static void
+identify_quit (FpDevice     *dev,
+               IdentifyData *identify_data)
+{
+  if (!fp_device_is_open (dev))
+    {
+      g_main_loop_quit (identify_data->loop);
+      return;
+    }
+
+  fp_device_close (dev, NULL, (GAsyncReadyCallback) on_device_closed, identify_data);
+}
+
+static void start_identification (FpDevice     *dev,
+                                  IdentifyData *identify_data);
+
+static void
+on_identify_completed (FpDevice *dev, GAsyncResult *res, void *user_data)
+{
+  IdentifyData *identify_data = user_data;
+
+  g_autoptr(FpPrint) print = NULL;
+  g_autoptr(FpPrint) match = NULL;
+  g_autoptr(GError) error = NULL;
+  char buffer[20];
+
+  if (!fp_device_identify_finish (dev, res, &match, &print, &error))
+    {
+      g_warning ("Failed to identify print: %s", error->message);
+      identify_data->ret_value = EXIT_FAILURE;
+
+      if (error->domain != FP_DEVICE_RETRY)
+        {
+          identify_quit (dev, identify_data);
+          return;
+        }
+    }
+
+  g_print ("Identify again? [Y/n]? ");
+  if (fgets (buffer, sizeof (buffer), stdin) &&
+      (buffer[0] == 'Y' || buffer[0] == 'y' || buffer[0] == '\n'))
+    {
+      start_identification (dev, identify_data);
+      return;
+    }
+
+  identify_quit (dev, identify_data);
+}
+
+static FpPrint *
+get_stored_print (FpDevice *dev, FpPrint *print)
+{
+  g_autoptr(GPtrArray) gallery = gallery_data_load (dev);
+  guint index;
+
+  if (g_ptr_array_find_with_equal_func (gallery, print,
+                                        (GEqualFunc) fp_print_equal,
+                                        &index))
+    return g_object_ref (g_ptr_array_index (gallery, index));
+
+  return NULL;
+}
+
+static void
+on_identify_cb (FpDevice *dev, FpPrint *match, FpPrint *print,
+                gpointer user_data, GError *error)
+{
+  IdentifyData *identify_data = user_data;
+
+  if (error)
+    {
+      g_warning ("Identify report: No finger matched, retry error reported: %s",
+                 error->message);
+      return;
+    }
+
+  if (print && fp_print_get_image (print) &&
+      print_image_save (print, "identify.pgm"))
+    g_print ("Print image saved as identify.pgm\n");
+
+  if (match)
+    {
+      g_autoptr(FpPrint) matched_print = g_object_ref (match);
+      char date_str[128] = {};
+
+      identify_data->ret_value = EXIT_SUCCESS;
+
+      if (fp_print_get_device_stored (match))
+        {
+          FpPrint *stored_print = get_stored_print (dev, match);
+
+          if (stored_print)
+            matched_print = g_steal_pointer (&stored_print);
+        }
+
+      if (fp_print_get_enroll_date (matched_print))
+        g_date_strftime (date_str, G_N_ELEMENTS (date_str), "%Y-%m-%d\0",
+                         fp_print_get_enroll_date (matched_print));
+      else
+        strcpy (date_str, "<unknown>");
+
+      g_debug ("Identify report: device %s matched finger %s successfully "
+               "with print '%s', enrolled on date %s by user %s",
+               fp_device_get_name (dev),
+               finger_to_string (fp_print_get_finger (matched_print)),
+               fp_print_get_description (matched_print), date_str,
+               fp_print_get_username (matched_print));
+
+      g_print ("IDENTIFIED!\n");
+    }
+  else
+    {
+      g_debug ("Identification report: No finger matched");
+      g_print ("NOT IDENTIFIED!\n");
+    }
+}
+
+static void
+on_list_completed (FpDevice *dev, GAsyncResult *res, gpointer user_data)
+{
+  IdentifyData *identify_data = user_data;
+
+  g_autoptr(GPtrArray) gallery = NULL;
+  g_autoptr(GError) error = NULL;
+
+  gallery = fp_device_list_prints_finish (dev, res, &error);
+
+  if (!error)
+    {
+      if (!gallery->len)
+        {
+          g_warning ("No prints saved on device");
+          identify_quit (dev, identify_data);
+          return;
+        }
+
+      g_debug ("Identifying with %u prints in gallery", gallery->len);
+      fp_device_identify (dev, gallery, identify_data->cancellable,
+                          on_identify_cb, identify_data, NULL,
+                          (GAsyncReadyCallback) on_identify_completed,
+                          identify_data);
+    }
+  else
+    {
+      g_warning ("Loading prints failed with error %s", error->message);
+      identify_quit (dev, identify_data);
+    }
+}
+
+static void
+start_identification (FpDevice *dev, IdentifyData *identify_data)
+{
+  if (fp_device_has_storage (dev))
+    {
+      g_print ("Creating finger template, using device storage...\n");
+      fp_device_list_prints (dev, NULL,
+                             (GAsyncReadyCallback) on_list_completed,
+                             identify_data);
+    }
+  else
+    {
+      g_autoptr(GPtrArray) gallery = gallery_data_load (dev);
+
+      if (!gallery)
+        {
+          identify_quit (dev, identify_data);
+          return;
+        }
+
+      g_print ("Gallery loaded. Time to identify!\n");
+      fp_device_identify (dev, gallery, identify_data->cancellable,
+                          on_identify_cb, identify_data, NULL,
+                          (GAsyncReadyCallback) on_identify_completed,
+                          identify_data);
+    }
+}
+
+static void
+on_device_opened (FpDevice *dev, GAsyncResult *res, void *user_data)
+{
+  IdentifyData *identify_data = user_data;
+
+  g_autoptr(GError) error = NULL;
+
+  if (!fp_device_open_finish (dev, res, &error))
+    {
+      g_warning ("Failed to open device: %s", error->message);
+      identify_quit (dev, identify_data);
+      return;
+    }
+
+  g_print ("Opened device. ");
+
+  start_identification (dev, identify_data);
+}
+
+static gboolean
+sigint_cb (void *user_data)
+{
+  IdentifyData *identify_data = user_data;
+
+  g_cancellable_cancel (identify_data->cancellable);
+
+  return G_SOURCE_CONTINUE;
+}
+
+int
+main (void)
+{
+  g_autoptr(FpContext) ctx = NULL;
+  g_autoptr(IdentifyData) identify_data = NULL;
+  GPtrArray *devices;
+  FpDevice *dev;
+
+  setenv ("G_MESSAGES_DEBUG", "all", 0);
+  setenv ("LIBUSB_DEBUG", "3", 0);
+
+  ctx = fp_context_new ();
+
+  devices = fp_context_get_devices (ctx);
+  if (!devices)
+    {
+      g_warning ("Impossible to get devices");
+      return EXIT_FAILURE;
+    }
+
+  dev = discover_device (devices);
+  if (!dev)
+    {
+      g_warning ("No devices detected.");
+      return EXIT_FAILURE;
+    }
+
+  if (!fp_device_supports_identify (dev))
+    {
+      g_warning ("Device %s does not support identification.",
+                 fp_device_get_name (dev));
+      return EXIT_FAILURE;
+    }
+
+  identify_data = g_new0 (IdentifyData, 1);
+  identify_data->ret_value = EXIT_FAILURE;
+  identify_data->loop = g_main_loop_new (NULL, FALSE);
+  identify_data->cancellable = g_cancellable_new ();
+  identify_data->sigint_handler = g_unix_signal_add_full (G_PRIORITY_HIGH,
+                                                          SIGINT,
+                                                          sigint_cb,
+                                                          identify_data,
+                                                          NULL);
+  fp_device_open (dev, identify_data->cancellable,
+                  (GAsyncReadyCallback) on_device_opened,
+                  identify_data);
+
+  g_main_loop_run (identify_data->loop);
+
+  return identify_data->ret_value;
+}

examples/meson.build

@@ -1,5 +1,12 @@
 
-examples = [ 'enroll', 'verify', 'manage-prints', 'img-capture' ]
+examples = [
+    'enroll',
+    'identify',
+    'img-capture',
+    'manage-prints',
+    'verify',
+]
+
 foreach example: examples
     executable(example,
         [ example + '.c', 'storage.c', 'utilities.c' ],

examples/storage.c

@@ -2,7 +2,7 @@
  * Trivial storage driver for example programs
  *
  * Copyright (C) 2019 Benjamin Berg <bberg@redhat.com>
- * Copyright (C) 2019 Marco Trevisan <marco.trevisan@canonical.com>
+ * Copyright (C) 2019-2020 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
@@ -160,6 +160,52 @@ print_data_load (FpDevice *dev, FpFinger finger)
   return NULL;
 }
 
+GPtrArray *
+gallery_data_load (FpDevice *dev)
+{
+  g_autoptr(GVariantDict) dict = NULL;
+  g_autoptr(GVariant) dict_variant = NULL;
+  g_autofree char *dev_prefix = NULL;
+  GPtrArray *gallery;
+  const char *driver;
+  const char *dev_id;
+  GVariantIter iter;
+  GVariant *value;
+  gchar *key;
+
+  gallery = g_ptr_array_new_with_free_func (g_object_unref);
+  dict = load_data ();
+  dict_variant = g_variant_dict_end (dict);
+  driver = fp_device_get_driver (dev);
+  dev_id = fp_device_get_device_id (dev);
+  dev_prefix = g_strdup_printf ("%s/%s/", driver, dev_id);
+
+  g_variant_iter_init (&iter, dict_variant);
+  while (g_variant_iter_loop (&iter, "{sv}", &key, &value))
+    {
+      FpPrint *print;
+      const guchar *stored_data;
+      g_autoptr(GError) error = NULL;
+      gsize stored_len;
+
+      if (!g_str_has_prefix (key, dev_prefix))
+        continue;
+
+      stored_data = (const guchar *) g_variant_get_fixed_array (value, &stored_len, 1);
+      print = fp_print_deserialize (stored_data, stored_len, &error);
+
+      if (error)
+        {
+          g_warning ("Error deserializing data: %s", error->message);
+          continue;
+        }
+
+      g_ptr_array_add (gallery, print);
+    }
+
+  return gallery;
+}
+
 FpPrint *
 print_create_template (FpDevice *dev, FpFinger finger)
 {

examples/storage.h

@@ -24,6 +24,7 @@ int print_data_save (FpPrint *print,
                      FpFinger finger);
 FpPrint * print_data_load (FpDevice *dev,
                            FpFinger  finger);
+GPtrArray * gallery_data_load (FpDevice *dev);
 FpPrint * print_create_template (FpDevice *dev,
                                  FpFinger  finger);
 gboolean print_image_save (FpPrint    *print,

examples/verify.c

@@ -152,6 +152,26 @@ on_match_cb (FpDevice *dev, FpPrint *match, FpPrint *print,
     }
 }
 
+static FpPrint *
+get_stored_print (FpDevice *dev, VerifyData *verify_data)
+{
+  FpPrint *verify_print;
+
+  g_print ("Loading previously enrolled %s finger data...\n",
+           finger_to_string (verify_data->finger));
+
+  verify_print = print_data_load (dev, verify_data->finger);
+
+  if (!verify_print)
+    {
+      g_warning ("Failed to load fingerprint data");
+      g_warning ("Did you remember to enroll your %s finger first?",
+                 finger_to_string (verify_data->finger));
+    }
+
+  return verify_print;
+}
+
 static void
 on_list_completed (FpDevice *dev, GAsyncResult *res, gpointer user_data)
 {
@@ -165,15 +185,27 @@ on_list_completed (FpDevice *dev, GAsyncResult *res, gpointer user_data)
   if (!error)
     {
       FpPrint *verify_print = NULL;
+      g_autoptr(FpPrint) stored_print = NULL;
       guint i;
 
       if (!prints->len)
+        {
           g_warning ("No prints saved on device");
+          verify_quit (dev, verify_data);
+          return;
+        }
+
+      stored_print = get_stored_print (dev, verify_data);
 
       for (i = 0; i < prints->len; ++i)
         {
           FpPrint *print = prints->pdata[i];
 
+          if (stored_print && fp_print_equal (stored_print, print))
+            /* If the private print data matches, let's use the stored print
+             * as it contains more metadata to show */
+            print = stored_print;
+
           if (fp_print_get_finger (print) == verify_data->finger &&
               g_strcmp0 (fp_print_get_username (print), g_get_user_name ()) == 0)
             {
@@ -191,8 +223,6 @@ on_list_completed (FpDevice *dev, GAsyncResult *res, gpointer user_data)
 
       if (!verify_print)
         {
-          g_warning ("Did you remember to enroll your %s finger first?",
-                     finger_to_string (verify_data->finger));
           verify_quit (dev, verify_data);
           return;
         }
@@ -239,17 +269,10 @@ start_verification (FpDevice *dev, VerifyData *verify_data)
     }
   else
     {
-      g_print ("Loading previously enrolled %s finger data...\n",
+      g_autoptr(FpPrint) verify_print = get_stored_print (dev, verify_data);
-               finger_to_string (verify_data->finger));
-      g_autoptr(FpPrint) verify_print = NULL;
-
-      verify_print = print_data_load (dev, verify_data->finger);
 
       if (!verify_print)
         {
-          g_warning ("Failed to load fingerprint data");
-          g_warning ("Did you remember to enroll your %s finger first?",
-                     finger_to_string (verify_data->finger));
           verify_quit (dev, verify_data);
           return;
         }

libfprint/drivers/aes1610.c

@@ -135,10 +135,8 @@ generic_read_ignore_data (FpiSsm *ssm, FpDevice *dev,
                           size_t bytes)
 {
   FpiUsbTransfer *transfer = fpi_usb_transfer_new (dev);
-  unsigned char *data;
 
-  data = g_malloc (bytes);
+  fpi_usb_transfer_fill_bulk (transfer, EP_IN, bytes);
-  fpi_usb_transfer_fill_bulk_full (transfer, EP_IN, data, bytes, g_free);
   transfer->ssm = ssm;
   transfer->short_is_error = TRUE;
   fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,

libfprint/drivers/aes3500.c

@@ -106,7 +106,9 @@ static struct aes_regwrite init_reqs[] = {
   { 0x9e, 0x53 },       /* clear challenge word bits */
   { 0x9f, 0x6b },       /* set some challenge word bits */
   { 0, 0 },
+};
 
+static struct aes_regwrite capture_reqs[] = {
   { 0x80, 0x00 },
   { 0x81, 0x00 },
   { 0, 0 },
@@ -155,4 +157,6 @@ fpi_device_aes3500_class_init (FpiDeviceAes3500Class *klass)
   aes_class->enlarge_factor = ENLARGE_FACTOR;
   aes_class->init_reqs = init_reqs;
   aes_class->init_reqs_len = G_N_ELEMENTS (init_reqs);
+  aes_class->capture_reqs = capture_reqs;
+  aes_class->capture_reqs_len = G_N_ELEMENTS (capture_reqs);
 }

libfprint/drivers/aes3k.c

@@ -42,7 +42,10 @@
 
 typedef struct
 {
-  GCancellable *img_trf_cancel;
+  /* This is used both as a flag that we are in a capture operation
+   * and for cancellation.
+   */
+  GCancellable *img_capture_cancel;
 } FpiDeviceAes3kPrivate;
 
 #define CTRL_TIMEOUT 1000
@@ -83,6 +86,9 @@ img_cb (FpiUsbTransfer *transfer, FpDevice *device,
   FpImage *img;
   int i;
 
+  /* Image capture operation is finished (error/completed) */
+  g_clear_object (&priv->img_capture_cancel);
+
   if (error)
     {
       if (g_error_matches (error,
@@ -91,13 +97,11 @@ img_cb (FpiUsbTransfer *transfer, FpDevice *device,
         {
           /* Cancellation implies we are deactivating. */
           g_error_free (error);
-          g_clear_object (&priv->img_trf_cancel);
           fpi_image_device_deactivate_complete (dev, NULL);
           return;
         }
 
       fpi_image_device_session_error (dev, error);
-      g_clear_object (&priv->img_trf_cancel);
       return;
     }
 
@@ -122,11 +126,10 @@ img_cb (FpiUsbTransfer *transfer, FpDevice *device,
   fpi_image_device_image_captured (dev, img);
 
   /* FIXME: rather than assuming finger has gone, we should poll regs until
-   * it really has, then restart the capture */
+   * it really has. */
   fpi_image_device_report_finger_status (dev, FALSE);
 
-  /* Note: We always restart the transfer, it may already be cancelled though. */
+  /* Note: The transfer is re-started when we switch to the AWAIT_FINGER_ON state. */
-  do_capture (dev);
 }
 
 static void
@@ -141,31 +144,51 @@ do_capture (FpImageDevice *dev)
   fpi_usb_transfer_fill_bulk (img_trf, EP_IN, cls->data_buflen);
   img_trf->short_is_error = TRUE;
   fpi_usb_transfer_submit (g_steal_pointer (&img_trf), 0,
-                           priv->img_trf_cancel,
+                           priv->img_capture_cancel,
                            img_cb, NULL);
 }
 
+static void
+capture_reqs_cb (FpImageDevice *dev, GError *result, void *user_data)
+{
+  FpiDeviceAes3k *self = FPI_DEVICE_AES3K (dev);
+  FpiDeviceAes3kPrivate *priv = fpi_device_aes3k_get_instance_private (self);
+
+  if (result)
+    {
+      g_clear_object (&priv->img_capture_cancel);
+      fpi_image_device_session_error (dev, result);
+      return;
+    }
+
+  /* FIXME: we never cancel a pending capture. So we are likely leaving the
+   * hardware in a bad state should we abort the capture operation and the
+   * user does not touch the device.
+   * But, we don't know how we might cancel, so just leave it as is. */
+  do_capture (dev);
+}
+
+static void
+do_capture_start (FpImageDevice *dev)
+{
+  FpiDeviceAes3k *self = FPI_DEVICE_AES3K (dev);
+  FpiDeviceAes3kClass *cls = FPI_DEVICE_AES3K_GET_CLASS (self);
+
+  aes_write_regv (dev, cls->capture_reqs, cls->capture_reqs_len, capture_reqs_cb, NULL);
+}
+
 static void
 init_reqs_cb (FpImageDevice *dev, GError *result, void *user_data)
 {
-  FpiDeviceAes3kPrivate *priv = fpi_device_aes3k_get_instance_private (FPI_DEVICE_AES3K (dev));
-
   fpi_image_device_activate_complete (dev, result);
-  if (!result)
-    {
-      priv->img_trf_cancel = g_cancellable_new ();
-      do_capture (dev);
-    }
 }
 
 static void
 aes3k_dev_activate (FpImageDevice *dev)
 {
   FpiDeviceAes3k *self = FPI_DEVICE_AES3K (dev);
-  FpiDeviceAes3kPrivate *priv = fpi_device_aes3k_get_instance_private (self);
   FpiDeviceAes3kClass *cls = FPI_DEVICE_AES3K_GET_CLASS (self);
 
-  g_assert (!priv->img_trf_cancel);
   aes_write_regv (dev, cls->init_reqs, cls->init_reqs_len, init_reqs_cb, NULL);
 }
 
@@ -175,13 +198,28 @@ aes3k_dev_deactivate (FpImageDevice *dev)
   FpiDeviceAes3k *self = FPI_DEVICE_AES3K (dev);
   FpiDeviceAes3kPrivate *priv = fpi_device_aes3k_get_instance_private (self);
 
-  /* Deactivation finishes from the cancellation handler */
+  /* If a capture is running, then deactivation finishes from the cancellation handler */
-  if (priv->img_trf_cancel)
+  if (priv->img_capture_cancel)
-    g_cancellable_cancel (priv->img_trf_cancel);
+    g_cancellable_cancel (priv->img_capture_cancel);
   else
     fpi_image_device_deactivate_complete (dev, NULL);
 }
 
+static void
+aes3k_dev_change_state (FpImageDevice *dev, FpiImageDeviceState state)
+{
+  FpiDeviceAes3k *self = FPI_DEVICE_AES3K (dev);
+  FpiDeviceAes3kPrivate *priv = fpi_device_aes3k_get_instance_private (self);
+
+  if (state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
+    {
+      g_assert (!priv->img_capture_cancel);
+      priv->img_capture_cancel = g_cancellable_new ();
+
+      do_capture_start (dev);
+    }
+}
+
 static void
 fpi_device_aes3k_init (FpiDeviceAes3k *self)
 {
@@ -224,6 +262,7 @@ fpi_device_aes3k_class_init (FpiDeviceAes3kClass *klass)
   img_class->img_open = aes3k_dev_init;
   img_class->img_close = aes3k_dev_deinit;
   img_class->activate = aes3k_dev_activate;
+  img_class->change_state = aes3k_dev_change_state;
   img_class->deactivate = aes3k_dev_deactivate;
 
   /* Extremely low due to low image quality. */

libfprint/drivers/aes3k.h

@@ -57,4 +57,6 @@ struct _FpiDeviceAes3kClass
   gsize                data_buflen;    /* buffer length of usb bulk transfer */
   struct aes_regwrite *init_reqs;       /* initial values sent to device */
   gsize                init_reqs_len;
+  struct aes_regwrite *capture_reqs;       /* capture values sent to device */
+  gsize                capture_reqs_len;
 };

libfprint/drivers/aes4000.c

@@ -103,7 +103,9 @@ static struct aes_regwrite init_reqs[] = {
   { 0x9e, 0x53 },       /* clear challenge word bits */
   { 0x9f, 0x6b },       /* set some challenge word bits */
   { 0, 0 },
+};
 
+static struct aes_regwrite capture_reqs[] = {
   { 0x80, 0x00 },
   { 0x81, 0x00 },
   { 0, 0 },
@@ -152,4 +154,6 @@ fpi_device_aes4000_class_init (FpiDeviceAes4000Class *klass)
   aes_class->enlarge_factor = ENLARGE_FACTOR;
   aes_class->init_reqs = init_reqs;
   aes_class->init_reqs_len = G_N_ELEMENTS (init_reqs);
+  aes_class->capture_reqs = capture_reqs;
+  aes_class->capture_reqs_len = G_N_ELEMENTS (capture_reqs);
 }

libfprint/drivers/aesx660.c

@@ -54,6 +54,7 @@ static void complete_deactivation (FpImageDevice *dev);
 #define CALIBRATE_DATA_LEN 4
 #define FINGER_DET_DATA_LEN 4
 
+FP_GNUC_ACCESS (read_only, 3, 4)
 static void
 aesX660_send_cmd_timeout (FpiSsm                *ssm,
                           FpDevice              *_dev,
@@ -70,6 +71,7 @@ aesX660_send_cmd_timeout (FpiSsm                *ssm,
   fpi_usb_transfer_submit (transfer, timeout, NULL, callback, NULL);
 }
 
+FP_GNUC_ACCESS (read_only, 3, 4)
 static void
 aesX660_send_cmd (FpiSsm                *ssm,
                   FpDevice              *dev,
@@ -89,13 +91,12 @@ aesX660_read_response (FpiSsm                *ssm,
                        FpiUsbTransferCallback callback)
 {
   FpiUsbTransfer *transfer = fpi_usb_transfer_new (_dev);
-  unsigned char *data;
   GCancellable *cancel = NULL;
 
   if (cancellable)
     cancel = fpi_device_get_cancellable (_dev);
-  data = g_malloc (buf_len);
+
-  fpi_usb_transfer_fill_bulk_full (transfer, EP_IN, data, buf_len, NULL);
+  fpi_usb_transfer_fill_bulk (transfer, EP_IN, buf_len);
   transfer->ssm = ssm;
   transfer->short_is_error = short_is_error;
   fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, cancel, callback, NULL);

libfprint/drivers/elan.c

@@ -73,9 +73,8 @@ struct _FpiDeviceElan
   /* end commands */
 
   /* state */
+  gboolean        active;
   gboolean        deactivating;
-  FpiImageDeviceState dev_state;
-  FpiImageDeviceState dev_state_next;
   unsigned char  *last_read;
   unsigned char   calib_atts_left;
   unsigned char   calib_status;
@@ -87,8 +86,6 @@ struct _FpiDeviceElan
   GSList         *frames;
   /* end state */
 };
-G_DECLARE_FINAL_TYPE (FpiDeviceElan, fpi_device_elan, FPI, DEVICE_ELAN,
-                      FpImageDevice);
 G_DEFINE_TYPE (FpiDeviceElan, fpi_device_elan, FP_TYPE_IMAGE_DEVICE);
 
 static int
@@ -487,7 +484,7 @@ stop_capture_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
 
 
   /* The device is inactive at this point. */
-  self->dev_state = FPI_IMAGE_DEVICE_STATE_INACTIVE;
+  self->active = FALSE;
 
   if (self->deactivating)
     {
@@ -505,16 +502,14 @@ stop_capture_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
 }
 
 static void
-elan_stop_capture (FpDevice *dev)
+elan_stop_capture (FpiDeviceElan *self)
 {
-  FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
-
   G_DEBUG_HERE ();
 
   elan_dev_reset_state (self);
 
   FpiSsm *ssm =
-    fpi_ssm_new (dev, stop_capture_run_state, STOP_CAPTURE_NUM_STATES);
+    fpi_ssm_new (FP_DEVICE (self), stop_capture_run_state, STOP_CAPTURE_NUM_STATES);
 
   fpi_ssm_start (ssm, stop_capture_complete);
 }
@@ -545,8 +540,6 @@ capture_run_state (FpiSsm *ssm, FpDevice *dev)
       break;
 
     case CAPTURE_READ_DATA:
-      self->dev_state = FPI_IMAGE_DEVICE_STATE_CAPTURE;
-
       /* 0x55 - finger present
        * 0xff - device not calibrated (probably) */
       if (self->last_read && self->last_read[0] == 0x55)
@@ -614,18 +607,21 @@ capture_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
       fpi_image_device_session_error (dev, error);
     }
 
+  /* Note: We always stop capturing even if that may not be needed always.
+   * Doing this between captures appears to make it at least less likely for
+   * devices to end up in a bad state.
+   */
+  elan_stop_capture (self);
 }
 
 static void
-elan_capture (FpDevice *dev)
+elan_capture (FpiDeviceElan *self)
 {
-  FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
-
   G_DEBUG_HERE ();
 
   elan_dev_reset_state (self);
   FpiSsm *ssm =
-    fpi_ssm_new (dev, capture_run_state, CAPTURE_NUM_STATES);
+    fpi_ssm_new (FP_DEVICE (self), capture_run_state, CAPTURE_NUM_STATES);
 
   fpi_ssm_start (ssm, capture_complete);
 }
@@ -777,33 +773,31 @@ calibrate_run_state (FpiSsm *ssm, FpDevice *dev)
 static void
 calibrate_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
 {
-  FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
-
   G_DEBUG_HERE ();
 
   if (error)
     {
-      self->dev_state = FPI_IMAGE_DEVICE_STATE_INACTIVE;
       fpi_image_device_session_error (FP_IMAGE_DEVICE (dev), error);
+      elan_stop_capture (FPI_DEVICE_ELAN (dev));
     }
   else
     {
-      elan_capture (dev);
+      elan_capture (FPI_DEVICE_ELAN (dev));
     }
-
 }
 
 static void
-elan_calibrate (FpDevice *dev)
+elan_calibrate (FpiDeviceElan *self)
 {
-  FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
-
   G_DEBUG_HERE ();
 
   elan_dev_reset_state (self);
+
+  g_return_if_fail (!self->active);
+  self->active = TRUE;
   self->calib_atts_left = ELAN_CALIBRATION_ATTEMPTS;
 
-  FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), calibrate_run_state,
+  FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (self), calibrate_run_state,
                              CALIBRATE_NUM_STATES);
 
   fpi_ssm_start (ssm, calibrate_complete);
@@ -958,98 +952,19 @@ dev_activate (FpImageDevice *dev)
   elan_activate (dev);
 }
 
-static void
-elan_change_state (FpImageDevice *idev)
-{
-  FpDevice *dev = FP_DEVICE (idev);
-  FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
-  FpiImageDeviceState next_state = self->dev_state_next;
-
-  if (self->dev_state == next_state)
-    {
-      fp_dbg ("already in %d", next_state);
-      return;
-    }
-  else
-    {
-      fp_dbg ("changing to %d", next_state);
-    }
-
-  switch (next_state)
-    {
-    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
-      /* activation completed or another enroll stage started */
-      self->dev_state = FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON;
-      elan_calibrate (dev);
-      break;
-
-    case FPI_IMAGE_DEVICE_STATE_CAPTURE:
-      /* not used */
-      break;
-
-    case FPI_IMAGE_DEVICE_STATE_INACTIVE:
-    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
-      elan_stop_capture (dev);
-      break;
-    }
-}
-
-static void
-elan_change_state_async (FpDevice *dev,
-                         void     *data)
-{
-  fp_dbg ("state change dev: %p", dev);
-  elan_change_state (FP_IMAGE_DEVICE (dev));
-}
-
 static void
 dev_change_state (FpImageDevice *dev, FpiImageDeviceState state)
 {
   FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
-  GSource *timeout;
 
   G_DEBUG_HERE ();
 
-  /* Inactive and await finger off are equivalent for the elan driver. */
+  /* Note: We always calibrate even if that may not be needed always.
-  if (state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
+   * Doing this for each capture appears to make it at least less likely for
-    state = FPI_IMAGE_DEVICE_STATE_INACTIVE;
+   * devices to end up in a bad state.
-
+   */
-  if (self->dev_state_next == state)
+  if (state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
-    {
+    elan_calibrate (self);
-      fp_dbg ("change to state %d already queued", state);
-      return;
-    }
-
-  switch (state)
-    {
-    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
-         * related to the previous state to complete */
-        self->dev_state_next = state;
-        timeout = fpi_device_add_timeout (FP_DEVICE (dev), 10,
-                                          elan_change_state_async,
-                                          NULL, NULL);
-
-        name = g_strdup_printf ("dev_change_state to %d", state);
-        g_source_set_name (timeout, name);
-        g_free (name);
-
-        break;
-      }
-
-    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;
-      break;
-
-    default:
-      g_assert_not_reached ();
-    }
 }
 
 static void
@@ -1059,19 +974,14 @@ dev_deactivate (FpImageDevice *dev)
 
   G_DEBUG_HERE ();
 
-  if (self->dev_state == FPI_IMAGE_DEVICE_STATE_INACTIVE)
+  if (!self->active)
-    {
     /* The device is inactive already, complete the operation immediately. */
     fpi_image_device_deactivate_complete (dev, NULL);
-    }
   else
-    {
     /* The device is not yet inactive, flag that we are deactivating (and
-       * need to signal back deactivation) and then ensure we will change
+     * need to signal back deactivation).
-       * to the inactive state eventually. */
+     * Note that any running capture will be cancelled already if needed. */
     self->deactivating = TRUE;
-      dev_change_state (dev, FPI_IMAGE_DEVICE_STATE_INACTIVE);
-    }
 }
 
 static void

libfprint/drivers/elan.h

@@ -70,6 +70,9 @@
 #define ELAN_CMD_TIMEOUT 10000
 #define ELAN_FINGER_TIMEOUT 200
 
+G_DECLARE_FINAL_TYPE (FpiDeviceElan, fpi_device_elan, FPI, DEVICE_ELAN,
+                      FpImageDevice);
+
 struct elan_cmd
 {
   unsigned char  cmd[ELAN_CMD_LEN];
@@ -211,6 +214,7 @@ static const FpIdEntry elan_id_table[] = {
   {.vid = ELAN_VEND_ID,  .pid = 0x0c32, .driver_data = ELAN_ALL_DEV},
   {.vid = ELAN_VEND_ID,  .pid = 0x0c33, .driver_data = ELAN_ALL_DEV},
   {.vid = ELAN_VEND_ID,  .pid = 0x0c42, .driver_data = ELAN_0C42},
+  {.vid = ELAN_VEND_ID,  .pid = 0x0c4d, .driver_data = ELAN_ALL_DEV},
   {.vid = 0,  .pid = 0,  .driver_data = 0},
 };
 
@@ -218,8 +222,8 @@ static void elan_cmd_done (FpiSsm *ssm);
 static void elan_cmd_read (FpiSsm   *ssm,
                            FpDevice *dev);
 
-static void elan_calibrate (FpDevice *dev);
+static void elan_calibrate (FpiDeviceElan *self);
-static void elan_capture (FpDevice *dev);
+static void elan_capture (FpiDeviceElan *self);
 
 static void dev_change_state (FpImageDevice      *dev,
                               FpiImageDeviceState state);

libfprint/drivers/synaptics/synaptics.c

@@ -31,6 +31,10 @@ static const FpIdEntry id_table[] = {
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xBD,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xE9,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xDF,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xF9,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xFC,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xC2,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xC9,  },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
 
@@ -79,10 +83,17 @@ cmd_receive_cb (FpiUsbTransfer *transfer,
       if (msg_resp.payload[0] == 0x01)
         {
           self->finger_on_sensor = TRUE;
+          fpi_device_report_finger_status_changes (device,
+                                                   FP_FINGER_STATUS_PRESENT,
+                                                   FP_FINGER_STATUS_NONE);
         }
       else
         {
           self->finger_on_sensor = FALSE;
+          fpi_device_report_finger_status_changes (device,
+                                                   FP_FINGER_STATUS_NONE,
+                                                   FP_FINGER_STATUS_PRESENT);
+
           if (self->cmd_complete_on_removal)
             {
               fpi_ssm_mark_completed (transfer->ssm);
@@ -194,12 +205,19 @@ cmd_interrupt_cb (FpiUsbTransfer *transfer,
       fpi_ssm_mark_failed (transfer->ssm, error);
       return;
     }
-  g_clear_pointer (&error, g_error_free);
 
-  if (transfer->buffer[0] & USB_ASYNC_MESSAGE_PENDING || error)
+  if (transfer->buffer[0] & USB_ASYNC_MESSAGE_PENDING)
+    {
       fpi_ssm_next_state (transfer->ssm);
+    }
   else
-    fpi_usb_transfer_submit (transfer, 1000, NULL, cmd_interrupt_cb, NULL);
+    {
+      fpi_usb_transfer_submit (fpi_usb_transfer_ref (transfer),
+                               0,
+                               NULL,
+                               cmd_interrupt_cb,
+                               NULL);
+    }
 }
 
 static void
@@ -586,6 +604,9 @@ verify_msg_cb (FpiDeviceSynaptics *self,
   switch (resp->response_id)
     {
     case BMKT_RSP_VERIFY_READY:
+      fpi_device_report_finger_status_changes (device,
+                                               FP_FINGER_STATUS_NEEDED,
+                                               FP_FINGER_STATUS_NONE);
       fp_info ("Place Finger on the Sensor!");
       break;
 
@@ -659,6 +680,155 @@ verify (FpDevice *device)
   synaptics_sensor_cmd (self, 0, BMKT_CMD_VERIFY_USER, user_id, user_id_len, verify_msg_cb);
 }
 
+static void
+identify_complete_after_finger_removal (FpiDeviceSynaptics *self)
+{
+  FpDevice *device = FP_DEVICE (self);
+
+  if (self->finger_on_sensor)
+    {
+      fp_dbg ("delaying identify report until after finger removal!");
+      self->cmd_complete_on_removal = TRUE;
+    }
+  else
+    {
+      fpi_device_identify_complete (device, NULL);
+    }
+}
+
+
+static void
+identify_msg_cb (FpiDeviceSynaptics *self,
+                 bmkt_response_t    *resp,
+                 GError             *error)
+{
+  FpDevice *device = FP_DEVICE (self);
+
+  if (error)
+    {
+      fpi_device_identify_complete (device, error);
+      return;
+    }
+
+  if (resp == NULL && self->cmd_complete_on_removal)
+    {
+      fpi_device_identify_complete (device, NULL);
+      return;
+    }
+
+  g_assert (resp != NULL);
+
+  switch (resp->response_id)
+    {
+    case BMKT_RSP_ID_READY:
+      fp_info ("Place Finger on the Sensor!");
+      break;
+
+    case BMKT_RSP_ID_FAIL:
+      if (resp->result == BMKT_SENSOR_STIMULUS_ERROR)
+        {
+          fp_info ("Match error occurred");
+          fpi_device_identify_report (device, NULL, NULL,
+                                      fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL));
+          identify_complete_after_finger_removal (self);
+        }
+      else if (resp->result == BMKT_FP_NO_MATCH)
+        {
+          fp_info ("Print didn't match");
+          fpi_device_identify_report (device, NULL, NULL, NULL);
+          identify_complete_after_finger_removal (self);
+        }
+      else if (resp->result == BMKT_FP_DATABASE_NO_RECORD_EXISTS)
+        {
+          fp_info ("Print is not in database");
+          fpi_device_identify_complete (device,
+                                        fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND));
+        }
+      else
+        {
+          fp_warn ("identify has failed: %d", resp->result);
+          fpi_device_identify_complete (device,
+                                        fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
+                                                                  "Unexpected result from device %d",
+                                                                  resp->result));
+        }
+      break;
+
+    case BMKT_RSP_ID_OK:
+      {
+        FpPrint *print = NULL;
+        GPtrArray *prints = NULL;
+        g_autoptr(GVariant) data = NULL;
+        guint8 finger;
+        const guint8 *user_id;
+        gsize user_id_len = 0;
+        gint cnt = 0;
+        gboolean find = FALSE;
+
+        fpi_device_get_identify_data (device, &prints);
+
+        for (cnt = 0; cnt < prints->len; cnt++)
+          {
+            print = g_ptr_array_index (prints, cnt);
+            g_object_get (print, "fpi-data", &data, NULL);
+            g_debug ("data is %p", data);
+            parse_print_data (data, &finger, &user_id, &user_id_len);
+            if (user_id)
+              {
+                if (memcmp (resp->response.id_resp.user_id, user_id, user_id_len) == 0)
+                  {
+                    find = TRUE;
+                    break;
+                  }
+              }
+          }
+        if(find)
+          {
+            fpi_device_identify_report (device, print, print, NULL);
+            fpi_device_identify_complete (device, NULL);
+          }
+        else
+          {
+            fpi_device_identify_report (device, NULL, NULL, NULL);
+            identify_complete_after_finger_removal (self);
+          }
+      }
+    }
+}
+
+static void
+identify (FpDevice *device)
+{
+  FpiDeviceSynaptics *self = FPI_DEVICE_SYNAPTICS (device);
+  FpPrint *print = NULL;
+  GPtrArray *prints = NULL;
+
+  g_autoptr(GVariant) data = NULL;
+  guint8 finger;
+  const guint8 *user_id;
+  gsize user_id_len = 0;
+  gint cnt = 0;
+
+  fpi_device_get_identify_data (device, &prints);
+
+  for (cnt = 0; cnt < prints->len; cnt++)
+    {
+      print = g_ptr_array_index (prints, cnt);
+      g_object_get (print, "fpi-data", &data, NULL);
+      g_debug ("data is %p", data);
+      if (!parse_print_data (data, &finger, &user_id, &user_id_len))
+        {
+          fpi_device_identify_complete (device,
+                                        fpi_device_error_new (FP_DEVICE_ERROR_DATA_INVALID));
+          return;
+        }
+    }
+  G_DEBUG_HERE ();
+
+  synaptics_sensor_cmd (self, 0, BMKT_CMD_ID_USER, NULL, 0, identify_msg_cb);
+}
+
+
 static void
 enroll_msg_cb (FpiDeviceSynaptics *self,
                bmkt_response_t    *resp,
@@ -680,6 +850,9 @@ enroll_msg_cb (FpiDeviceSynaptics *self,
     case BMKT_RSP_ENROLL_READY:
       {
         self->enroll_stage = 0;
+        fpi_device_report_finger_status_changes (device,
+                                                 FP_FINGER_STATUS_NEEDED,
+                                                 FP_FINGER_STATUS_NONE);
         fp_info ("Place Finger on the Sensor!");
         break;
       }
@@ -1152,6 +1325,7 @@ fpi_device_synaptics_class_init (FpiDeviceSynapticsClass *klass)
   dev_class->close = dev_exit;
   dev_class->probe = dev_probe;
   dev_class->verify = verify;
+  dev_class->identify = identify;
   dev_class->enroll = enroll;
   dev_class->delete = delete_print;
   dev_class->cancel = cancel;

libfprint/drivers/upektc_img.c

@@ -78,6 +78,7 @@ upektc_img_cmd_update_crc (unsigned char *cmd_buf, size_t size)
   cmd_buf[size - 1] = (crc & 0xff00) >> 8;
 }
 
+FP_GNUC_ACCESS (read_only, 3, 4)
 static void
 upektc_img_submit_req (FpiSsm                *ssm,
                        FpImageDevice         *dev,

libfprint/drivers/upekts.c

@@ -527,15 +527,6 @@ initsm_read_msg_response_cb (FpiSsm            *ssm,
                            fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
                                                      "Unexpected response subcommand"));
     }
-  else if (seq != upekdev->seq)
-    {
-      fp_err ("expected response to cmd seq=%02x, got response to %02x "
-              "in state %d", upekdev->seq, seq,
-              fpi_ssm_get_cur_state (ssm));
-      fpi_ssm_mark_failed (ssm,
-                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                                     "Unexpected sequence number in response"));
-    }
   else
     {
       fpi_ssm_next_state (ssm);

libfprint/drivers/uru4000.c

@@ -412,18 +412,6 @@ dev_change_state (FpImageDevice *dev, FpiImageDeviceState state)
 {
   FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (dev);
 
-  switch (state)
-    {
-    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:
-      g_assert_not_reached ();
-    }
-
   self->activate_state = state;
   if (self->img_transfer != NULL)
     return;
@@ -663,7 +651,11 @@ imaging_run_state (FpiSsm *ssm, FpDevice *_dev)
     case IMAGING_CAPTURE:
       self->img_lines_done = 0;
       self->img_block = 0;
-      fpi_usb_transfer_submit (self->img_transfer, 0, NULL, image_transfer_cb, NULL);
+      fpi_usb_transfer_submit (fpi_usb_transfer_ref (self->img_transfer),
+                               0,
+                               NULL,
+                               image_transfer_cb,
+                               NULL);
 
       break;
 
@@ -799,8 +791,7 @@ imaging_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
   if (error)
     fpi_image_device_session_error (FP_IMAGE_DEVICE (dev), error);
 
-  /* Freed by callback or cancellation */
+  g_clear_pointer (&self->img_transfer, fpi_usb_transfer_unref);
-  self->img_transfer = NULL;
 
   g_free (self->img_data);
   self->img_data = NULL;
@@ -1182,7 +1173,10 @@ deactivate_write_reg_cb (FpiUsbTransfer *transfer, FpDevice *dev,
 static void
 dev_deactivate (FpImageDevice *dev)
 {
-  dev_change_state (dev, FPI_IMAGE_DEVICE_STATE_INACTIVE);
+  /* This is started/handled by execute_state_change in order to delay the
+   * action until after the image transfer has completed.
+   * We just need to override the function so that the complete handler is
+   * not called automatically. */
 }
 
 static void
@@ -1193,7 +1187,7 @@ execute_state_change (FpImageDevice *dev)
 
   switch (self->activate_state)
     {
-    case FPI_IMAGE_DEVICE_STATE_INACTIVE:
+    case FPI_IMAGE_DEVICE_STATE_DEACTIVATING:
       fp_dbg ("deactivating");
       self->irq_cb = NULL;
       self->irq_cb_data = NULL;
@@ -1248,6 +1242,12 @@ execute_state_change (FpImageDevice *dev)
       write_reg (dev, REG_MODE, MODE_AWAIT_FINGER_OFF,
                  change_state_write_reg_cb, NULL);
       break;
+
+    /* Ignored states */
+    case FPI_IMAGE_DEVICE_STATE_IDLE:
+    case FPI_IMAGE_DEVICE_STATE_ACTIVATING:
+    case FPI_IMAGE_DEVICE_STATE_INACTIVE:
+      break;
     }
 }
 

libfprint/drivers/vfs0050.c

@@ -42,6 +42,7 @@ async_write_callback (FpiUsbTransfer *transfer, FpDevice *device,
 }
 
 /* Send data to EP1, the only out endpoint */
+FP_GNUC_ACCESS (read_only, 3, 4)
 static void
 async_write (FpiSsm   *ssm,
              FpDevice *dev,

libfprint/drivers/vfs301.c

@@ -147,18 +147,6 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev)
     }
 }
 
-/* Complete loop sequential state machine */
-static void
-m_loop_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
-{
-  if (error)
-    {
-      g_warning ("State machine completed with an error: %s", error->message);
-      g_error_free (error);
-    }
-  /* Free sequential state machine */
-}
-
 /* Exec init sequential state machine */
 static void
 m_init_state (FpiSsm *ssm, FpDevice *_dev)
@@ -176,19 +164,7 @@ m_init_state (FpiSsm *ssm, FpDevice *_dev)
 static void
 m_init_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
 {
-  FpiSsm *ssm_loop;
-
   fpi_image_device_activate_complete (FP_IMAGE_DEVICE (dev), error);
-  if (!error)
-    {
-      /* Notify activate complete */
-
-      /* Start loop ssm */
-      ssm_loop = fpi_ssm_new (dev, m_loop_state, M_LOOP_NUM_STATES);
-      fpi_ssm_start (ssm_loop, m_loop_complete);
-    }
-
-  /* Free sequential state machine */
 }
 
 /* Activate device */
@@ -213,6 +189,19 @@ dev_deactivate (FpImageDevice *dev)
   fpi_image_device_deactivate_complete (dev, NULL);
 }
 
+static void
+dev_change_state (FpImageDevice *dev, FpiImageDeviceState state)
+{
+  FpiSsm *ssm_loop;
+
+  if (state != FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
+    return;
+
+  /* Start a capture operation. */
+  ssm_loop = fpi_ssm_new (FP_DEVICE (dev), m_loop_state, M_LOOP_NUM_STATES);
+  fpi_ssm_start (ssm_loop, NULL);
+}
+
 static void
 dev_open (FpImageDevice *dev)
 {
@@ -273,6 +262,7 @@ fpi_device_vfs301_class_init (FpDeviceVfs301Class *klass)
   img_class->img_close = dev_close;
   img_class->activate = dev_activate;
   img_class->deactivate = dev_deactivate;
+  img_class->change_state = dev_change_state;
 
   img_class->bz3_threshold = 24;
 

libfprint/drivers/vfs301_proto.c

@@ -93,6 +93,7 @@ usb_recv (FpDeviceVfs301 *dev, guint8 endpoint, int max_bytes, FpiUsbTransfer **
     *out = g_steal_pointer (&transfer);
 }
 
+FP_GNUC_ACCESS (read_only, 2, 3)
 static void
 usb_send (FpDeviceVfs301 *dev, const guint8 *data, gssize length, GError **error)
 {
@@ -212,11 +213,9 @@ vfs301_proto_generate (int type, int subtype, gssize *len)
         *len = 1;
         return data;
       }
-      break;
 
     case 0x0B:
       return vfs301_proto_generate_0B (subtype, len);
-      break;
 
     case 0x02D0:
       {
@@ -232,22 +231,18 @@ vfs301_proto_generate (int type, int subtype, gssize *len)
         g_assert ((int) subtype <= G_N_ELEMENTS (dataLs));
         return translate_str (dataLs[subtype - 1], len);
       }
-      break;
 
     case 0x0220:
       switch (subtype)
         {
         case 1:
           return translate_str (vfs301_0220_01, len);
-          break;
 
         case 2:
           return translate_str (vfs301_0220_02, len);
-          break;
 
         case 3:
           return translate_str (vfs301_0220_03, len);
-          break;
 
         case 0xFA00:
         case 0x2C01:
@@ -270,7 +265,6 @@ vfs301_proto_generate (int type, int subtype, gssize *len)
             field[3] = field[1];
 
             return data;
-            break;
           }
 
         default:
@@ -508,30 +502,30 @@ vfs301_proto_process_event_cb (FpiUsbTransfer *transfer,
                                FpDevice *device,
                                gpointer user_data, GError *error)
 {
-  FpDeviceVfs301 *dev = user_data;
+  FpDeviceVfs301 *self = FPI_DEVICE_VFS301 (device);
 
   if (error)
     {
       g_warning ("Error receiving data: %s", error->message);
       g_error_free (error);
-      dev->recv_progress = VFS301_FAILURE;
+      self->recv_progress = VFS301_FAILURE;
       return;
     }
   else if (transfer->actual_length < transfer->length)
     {
       /* TODO: process the data anyway? */
-      dev->recv_progress = VFS301_ENDED;
+      self->recv_progress = VFS301_ENDED;
       return;
     }
   else
     {
       FpiUsbTransfer *new;
-      if (!vfs301_proto_process_data (dev,
+      if (!vfs301_proto_process_data (self,
                                       transfer->length == VFS301_FP_RECV_LEN_1,
                                       transfer->buffer,
                                       transfer->actual_length))
         {
-          dev->recv_progress = VFS301_ENDED;
+          self->recv_progress = VFS301_ENDED;
           return;
         }
 

libfprint/drivers/virtual-image.c

@@ -42,6 +42,7 @@ struct _FpDeviceVirtualImage
 
   GSocketListener   *listener;
   GSocketConnection *connection;
+  GCancellable      *listen_cancellable;
   GCancellable      *cancellable;
 
   gint               socket_fd;
@@ -72,14 +73,21 @@ recv_image_img_recv_cb (GObject      *source_object,
 
   success = g_input_stream_read_all_finish (G_INPUT_STREAM (source_object), res, &bytes, &error);
 
-  if (!success || bytes == 0)
+  /* Can't use self if the operation was cancelled. */
+  if (!success && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+    return;
+
+  self = FPI_DEVICE_VIRTUAL_IMAGE (user_data);
+  device = FP_IMAGE_DEVICE (self);
+
+  /* Consider success if we received the right amount of data, otherwise
+   * an error must have happened. */
+  if (bytes < self->recv_img->width * self->recv_img->height)
     {
       if (!success)
-        {
+        g_warning ("Error receiving image data: %s", error->message);
-          if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+      else
-            return;
+        g_warning ("Error receiving image data: end of stream before all data was read");
-          g_warning ("Error receiving header for image data: %s", error->message);
-        }
 
       self = FPI_DEVICE_VIRTUAL_IMAGE (user_data);
       g_io_stream_close (G_IO_STREAM (self->connection), NULL, NULL);
@@ -87,9 +95,6 @@ recv_image_img_recv_cb (GObject      *source_object,
       return;
     }
 
-  self = FPI_DEVICE_VIRTUAL_IMAGE (user_data);
-  device = FP_IMAGE_DEVICE (self);
-
   if (self->automatic_finger)
     fpi_image_device_report_finger_status (device, TRUE);
   fpi_image_device_image_captured (device, g_steal_pointer (&self->recv_img));
@@ -112,7 +117,7 @@ recv_image_hdr_recv_cb (GObject      *source_object,
 
   success = g_input_stream_read_all_finish (G_INPUT_STREAM (source_object), res, &bytes, &error);
 
-  if (!success || bytes == 0)
+  if (!success || bytes != sizeof (self->recv_img_hdr))
     {
       if (!success)
         {
@@ -121,6 +126,10 @@ recv_image_hdr_recv_cb (GObject      *source_object,
             return;
           g_warning ("Error receiving header for image data: %s", error->message);
         }
+      else if (bytes != 0)
+        {
+          g_warning ("Received incomplete header before end of stream.");
+        }
 
       self = FPI_DEVICE_VIRTUAL_IMAGE (user_data);
       g_io_stream_close (G_IO_STREAM (self->connection), NULL, NULL);
@@ -162,6 +171,11 @@ recv_image_hdr_recv_cb (GObject      *source_object,
                                                  !!self->recv_img_hdr[1]);
           break;
 
+        case -5:
+          /* -5 causes the device to disappear (no further data) */
+          fpi_device_remove (FP_DEVICE (self));
+          break;
+
         default:
           /* disconnect client, it didn't play fair */
           g_io_stream_close (G_IO_STREAM (self->connection), NULL, NULL);
@@ -185,15 +199,25 @@ recv_image_hdr_recv_cb (GObject      *source_object,
 }
 
 static void
-recv_image (FpDeviceVirtualImage *dev, GInputStream *stream)
+recv_image (FpDeviceVirtualImage *self, GInputStream *stream)
+{
+  FpiImageDeviceState state;
+
+  g_object_get (self, "fpi-image-device-state", &state, NULL);
+
+  g_debug ("Starting image receive (if active), state is: %i", state);
+
+  /* Only register if the state is active. */
+  if (state >= FPI_IMAGE_DEVICE_STATE_IDLE)
     {
       g_input_stream_read_all_async (stream,
-                                 dev->recv_img_hdr,
+                                     self->recv_img_hdr,
-                                 sizeof (dev->recv_img_hdr),
+                                     sizeof (self->recv_img_hdr),
                                      G_PRIORITY_DEFAULT,
-                                 dev->cancellable,
+                                     self->cancellable,
                                      recv_image_hdr_recv_cb,
-                                 dev);
+                                     self);
+    }
 }
 
 static void
@@ -217,11 +241,25 @@ new_connection_cb (GObject *source_object, GAsyncResult *res, gpointer user_data
       start_listen (dev);
     }
 
-  /* Always further connections (but we disconnect them immediately
+  /* Always accept further connections (but we disconnect them immediately
    * if we already have a connection). */
   start_listen (dev);
+
   if (dev->connection)
     {
+      /* We may not have noticed that the stream was closed,
+       * if the device is deactivated.
+       * Cancel any ongoing operation on the old connection. */
+      g_cancellable_cancel (dev->cancellable);
+      g_clear_object (&dev->cancellable);
+      dev->cancellable = g_cancellable_new ();
+
+      g_clear_object (&dev->connection);
+    }
+
+  if (dev->connection)
+    {
+      g_warning ("Rejecting new connection");
       g_io_stream_close (G_IO_STREAM (connection), NULL, NULL);
       g_object_unref (connection);
       return;
@@ -231,16 +269,15 @@ new_connection_cb (GObject *source_object, GAsyncResult *res, gpointer user_data
   dev->automatic_finger = TRUE;
   stream = g_io_stream_get_input_stream (G_IO_STREAM (connection));
 
-  recv_image (dev, stream);
-
   fp_dbg ("Got a new connection!");
+  recv_image (dev, stream);
 }
 
 static void
 start_listen (FpDeviceVirtualImage *dev)
 {
   g_socket_listener_accept_async (dev->listener,
-                                  dev->cancellable,
+                                  dev->listen_cancellable,
                                   new_connection_cb,
                                   dev);
 }
@@ -285,6 +322,7 @@ dev_init (FpImageDevice *dev)
 
   self->listener = g_steal_pointer (&listener);
   self->cancellable = g_cancellable_new ();
+  self->listen_cancellable = g_cancellable_new ();
 
   start_listen (self);
 
@@ -300,7 +338,9 @@ dev_deinit (FpImageDevice *dev)
   G_DEBUG_HERE ();
 
   g_cancellable_cancel (self->cancellable);
+  g_cancellable_cancel (self->listen_cancellable);
   g_clear_object (&self->cancellable);
+  g_clear_object (&self->listen_cancellable);
   g_clear_object (&self->listener);
   g_clear_object (&self->connection);
 
@@ -308,18 +348,60 @@ dev_deinit (FpImageDevice *dev)
   fpi_device_add_timeout (FP_DEVICE (dev), 100, (FpTimeoutFunc) fpi_image_device_close_complete, NULL, NULL);
 }
 
+static void
+dev_activate (FpImageDevice *dev)
+{
+  FpDeviceVirtualImage *self = FPI_DEVICE_VIRTUAL_IMAGE (dev);
+
+  fpi_image_device_activate_complete (dev, NULL);
+
+  if (self->connection)
+    recv_image (self, g_io_stream_get_input_stream (G_IO_STREAM (self->connection)));
+}
+
 static void
 dev_deactivate (FpImageDevice *dev)
 {
-  G_DEBUG_HERE ();
+  FpDeviceVirtualImage *self = FPI_DEVICE_VIRTUAL_IMAGE (dev);
 
-  /* Delay result to open up the possibility of testing race conditions. */
+  g_cancellable_cancel (self->cancellable);
-  fpi_device_add_timeout (FP_DEVICE (dev), 100, (FpTimeoutFunc) fpi_image_device_deactivate_complete, NULL, NULL);
+  g_clear_object (&self->cancellable);
+  self->cancellable = g_cancellable_new ();
+
+  /* XXX: Need to wait for the operation to be cancelled. */
+  fpi_device_add_timeout (FP_DEVICE (dev), 10, (FpTimeoutFunc) fpi_image_device_deactivate_complete, NULL, NULL);
+}
+
+static void
+dev_notify_removed_cb (FpDevice *dev)
+{
+  FpiImageDeviceState state;
+  gboolean removed;
+
+  g_object_get (dev,
+                "fpi-image-device-state", &state,
+                "removed", &removed,
+                NULL);
+
+  if (!removed || state == FPI_IMAGE_DEVICE_STATE_INACTIVE)
+    return;
+
+  /* This error will be converted to an FP_DEVICE_ERROR_REMOVED by the
+   * surrounding layers. */
+  fpi_image_device_session_error (FP_IMAGE_DEVICE (dev),
+                                  fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
 }
 
 static void
 fpi_device_virtual_image_init (FpDeviceVirtualImage *self)
 {
+  /* NOTE: This is not nice, but we can generally rely on the underlying
+   *       system to throw errors on the transport layer.
+   */
+  g_signal_connect (self,
+                    "notify::removed",
+                    G_CALLBACK (dev_notify_removed_cb),
+                    NULL);
 }
 
 static const FpIdEntry driver_ids[] = {
@@ -341,5 +423,6 @@ fpi_device_virtual_image_class_init (FpDeviceVirtualImageClass *klass)
   img_class->img_open = dev_init;
   img_class->img_close = dev_deinit;
 
+  img_class->activate = dev_activate;
   img_class->deactivate = dev_deactivate;
 }

libfprint/fp-context.c

@@ -86,6 +86,60 @@ is_driver_allowed (const gchar *driver)
   return FALSE;
 }
 
+typedef struct
+{
+  FpContext *context;
+  FpDevice  *device;
+} RemoveDeviceData;
+
+static gboolean
+remove_device_idle_cb (RemoveDeviceData *data)
+{
+  FpContextPrivate *priv = fp_context_get_instance_private (data->context);
+  guint idx = 0;
+
+  g_return_val_if_fail (g_ptr_array_find (priv->devices, data->device, &idx), G_SOURCE_REMOVE);
+
+  g_signal_emit (data->context, signals[DEVICE_REMOVED_SIGNAL], 0, data->device);
+  g_ptr_array_remove_index_fast (priv->devices, idx);
+
+  g_free (data);
+
+  return G_SOURCE_REMOVE;
+}
+
+static void
+remove_device (FpContext *context, FpDevice *device)
+{
+  RemoveDeviceData *data;
+
+  data = g_new (RemoveDeviceData, 1);
+  data->context = context;
+  data->device = device;
+
+  g_idle_add ((GSourceFunc) remove_device_idle_cb, data);
+}
+
+static void
+device_remove_on_notify_open_cb (FpContext *context, GParamSpec *pspec, FpDevice *device)
+{
+  remove_device (context, device);
+}
+
+static void
+device_removed_cb (FpContext *context, FpDevice *device)
+{
+  gboolean open = FALSE;
+
+  g_object_get (device, "open", &open, NULL);
+
+  /* Wait for device close if the device is currently still open. */
+  if (open)
+    g_signal_connect_swapped (device, "notify::open", (GCallback) device_remove_on_notify_open_cb, context);
+  else
+    remove_device (context, device);
+}
+
 static void
 async_device_init_done_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
 {
@@ -110,6 +164,9 @@ async_device_init_done_cb (GObject *source_object, GAsyncResult *res, gpointer u
     }
 
   g_ptr_array_add (priv->devices, device);
+
+  g_signal_connect_swapped (device, "removed", (GCallback) device_removed_cb, context);
+
   g_signal_emit (context, signals[DEVICE_ADDED_SIGNAL], 0, device);
 }
 
@@ -189,12 +246,7 @@ usb_device_removed_cb (FpContext *self, GUsbDevice *device, GUsbContext *usb_ctx
         continue;
 
       if (fpi_device_get_usb_device (dev) == device)
-        {
+        fpi_device_remove (dev);
-          g_signal_emit (self, signals[DEVICE_REMOVED_SIGNAL], 0, dev);
-          g_ptr_array_remove_index_fast (priv->devices, i);
-
-          return;
-        }
     }
 }
 
@@ -248,6 +300,10 @@ fp_context_class_init (FpContextClass *klass)
    * @device: A #FpDevice
    *
    * This signal is emitted when a fingerprint reader is removed.
+   *
+   * It is guaranteed that the device has been closed before this signal
+   * is emitted. See the #FpDevice removed signal documentation for more
+   * information.
    **/
   signals[DEVICE_REMOVED_SIGNAL] = g_signal_new ("device-removed",
                                                  G_TYPE_FROM_CLASS (klass),

libfprint/fp-device-private.h

@@ -29,6 +29,7 @@ typedef struct
   GUsbDevice  *usb_device;
   const gchar *virtual_env;
 
+  gboolean     is_removed;
   gboolean     is_open;
 
   gchar       *device_id;
@@ -50,6 +51,7 @@ typedef struct
 
   /* State for tasks */
   gboolean            wait_for_finger;
+  FpFingerStatusFlags finger_status;
 } FpDevicePrivate;
 
 

libfprint/fp-device.c

@@ -44,8 +44,10 @@ enum {
   PROP_DEVICE_ID,
   PROP_NAME,
   PROP_OPEN,
+  PROP_REMOVED,
   PROP_NR_ENROLL_STAGES,
   PROP_SCAN_TYPE,
+  PROP_FINGER_STATUS,
   PROP_FPI_ENVIRON,
   PROP_FPI_USB_DEVICE,
   PROP_FPI_DRIVER_DATA,
@@ -54,6 +56,13 @@ enum {
 
 static GParamSpec *properties[N_PROPS];
 
+enum {
+  REMOVED_SIGNAL,
+  N_SIGNALS
+};
+
+static guint signals[N_SIGNALS] = { 0, };
+
 /**
  * fp_device_retry_quark:
  *
@@ -84,6 +93,8 @@ fp_device_cancel_in_idle_cb (gpointer user_data)
 
   cls->cancel (self);
 
+  fpi_device_report_finger_status (self, FP_FINGER_STATUS_NONE);
+
   return G_SOURCE_REMOVE;
 }
 
@@ -181,6 +192,10 @@ fp_device_get_property (GObject    *object,
       g_value_set_enum (value, priv->scan_type);
       break;
 
+    case PROP_FINGER_STATUS:
+      g_value_set_enum (value, priv->finger_status);
+      break;
+
     case PROP_DRIVER:
       g_value_set_static_string (value, FP_DEVICE_GET_CLASS (priv)->id);
       break;
@@ -197,6 +212,10 @@ fp_device_get_property (GObject    *object,
       g_value_set_boolean (value, priv->is_open);
       break;
 
+    case PROP_REMOVED:
+      g_value_set_boolean (value, priv->is_removed);
+      break;
+
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
     }
@@ -310,6 +329,13 @@ fp_device_class_init (FpDeviceClass *klass)
                        FP_TYPE_SCAN_TYPE, FP_SCAN_TYPE_SWIPE,
                        G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
 
+  properties[PROP_FINGER_STATUS] =
+    g_param_spec_flags ("finger-status",
+                        "FingerStatus",
+                        "The status of the finger",
+                        FP_TYPE_FINGER_STATUS_FLAGS, FP_FINGER_STATUS_NONE,
+                        G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
+
   properties[PROP_DRIVER] =
     g_param_spec_string ("driver",
                          "Driver",
@@ -337,6 +363,41 @@ fp_device_class_init (FpDeviceClass *klass)
                           "Whether the device is open or not", FALSE,
                           G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
 
+  properties[PROP_REMOVED] =
+    g_param_spec_boolean ("removed",
+                          "Removed",
+                          "Whether the device has been removed from the system", FALSE,
+                          G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
+
+  /**
+   * FpDevice::removed:
+   * @device: the #FpDevice instance that emitted the signal
+   *
+   * This signal is emitted after the device has been removed and no operation
+   * is pending anymore.
+   *
+   * The API user is still required to close a removed device. The above
+   * guarantee means that the call to close the device can be made immediately
+   * from the signal handler.
+   *
+   * The close operation will return FP_DEVICE_ERROR_REMOVED, but the device
+   * will still be considered closed afterwards.
+   *
+   * The device will only be removed from the #FpContext after it has been
+   * closed by the API user.
+   **/
+  signals[REMOVED_SIGNAL] = g_signal_new ("removed",
+                                          G_TYPE_FROM_CLASS (klass),
+                                          G_SIGNAL_RUN_LAST,
+                                          0,
+                                          NULL,
+                                          NULL,
+                                          g_cclosure_marshal_VOID__VOID,
+                                          G_TYPE_NONE,
+                                          0);
+
+  /* Private properties */
+
   /**
    * FpDevice::fpi-environ: (skip)
    *
@@ -469,6 +530,26 @@ fp_device_get_scan_type (FpDevice *device)
   return priv->scan_type;
 }
 
+/**
+ * fp_device_get_finger_status:
+ * @device: A #FpDevice
+ *
+ * Retrieves the finger status flags for the device.
+ * This can be used by the UI to present the relevant feedback, although it
+ * is not guaranteed to be a relevant value when not performing any action.
+ *
+ * Returns: The current #FpFingerStatusFlags
+ */
+FpFingerStatusFlags
+fp_device_get_finger_status (FpDevice *device)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+
+  g_return_val_if_fail (FP_IS_DEVICE (device), FP_SCAN_TYPE_SWIPE);
+
+  return priv->finger_status;
+}
+
 /**
  * fp_device_get_nr_enroll_stages:
  * @device: A #FpDevice
@@ -603,6 +684,7 @@ fp_device_open (FpDevice           *device,
   priv->current_action = FPI_DEVICE_ACTION_OPEN;
   priv->current_task = g_steal_pointer (&task);
   maybe_cancel_on_cancelled (device, cancellable);
+  fpi_device_report_finger_status (device, FP_FINGER_STATUS_NONE);
 
   FP_DEVICE_GET_CLASS (device)->open (device);
 }

libfprint/fp-device.h

@@ -91,6 +91,7 @@ typedef enum {
  * @FP_DEVICE_ERROR_DATA_NOT_FOUND: Requested print was not found on device
  * @FP_DEVICE_ERROR_DATA_FULL: No space on device available for operation
  * @FP_DEVICE_ERROR_DATA_DUPLICATE: Enrolling template duplicates storaged templates
+ * @FP_DEVICE_ERROR_REMOVED: The device has been removed.
  *
  * Error codes for device operations. More specific errors from other domains
  * such as #G_IO_ERROR or #G_USB_DEVICE_ERROR may also be reported.
@@ -106,6 +107,8 @@ typedef enum {
   FP_DEVICE_ERROR_DATA_NOT_FOUND,
   FP_DEVICE_ERROR_DATA_FULL,
   FP_DEVICE_ERROR_DATA_DUPLICATE,
+  /* Leave some room to add more DATA related errors */
+  FP_DEVICE_ERROR_REMOVED = 0x100,
 } FpDeviceError;
 
 GQuark fp_device_retry_quark (void);
@@ -170,6 +173,7 @@ const gchar *fp_device_get_device_id (FpDevice *device);
 const gchar *fp_device_get_name (FpDevice *device);
 gboolean     fp_device_is_open (FpDevice *device);
 FpScanType   fp_device_get_scan_type (FpDevice *device);
+FpFingerStatusFlags fp_device_get_finger_status (FpDevice *device);
 gint         fp_device_get_nr_enroll_stages (FpDevice *device);
 
 gboolean     fp_device_supports_identify (FpDevice *device);

libfprint/fp-image-device-private.h

@@ -27,17 +27,19 @@ typedef struct
 {
   FpiImageDeviceState state;
   gboolean            active;
-  gboolean            cancelling;
 
-  gboolean            enroll_await_on_pending;
+  gboolean            finger_present;
+
   gint                enroll_stage;
 
-  guint               pending_activation_timeout_id;
+  gboolean            minutiae_scan_active;
-  gboolean            pending_activation_timeout_waiting_finger_off;
+  GError             *action_error;
+  FpImage            *capture_image;
 
   gint                bz3_threshold;
 } FpImageDevicePrivate;
 
 
 void fpi_image_device_activate (FpImageDevice *image_device);
-void fpi_image_device_deactivate (FpImageDevice *image_device);
+void fpi_image_device_deactivate (FpImageDevice *image_device,
+                                  gboolean       cancelling);

libfprint/fp-image-device.c

@@ -56,44 +56,6 @@ static guint signals[LAST_SIGNAL] = { 0 };
  * - sanitize_image seems a bit odd, in particular the sizing stuff.
  **/
 
-/* Static helper functions */
-
-static gboolean
-pending_activation_timeout (gpointer user_data)
-{
-  FpImageDevice *self = FP_IMAGE_DEVICE (user_data);
-  FpDevice *device = FP_DEVICE (self);
-  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
-  FpiDeviceAction action = fpi_device_get_current_action (device);
-  GError *error;
-
-  priv->pending_activation_timeout_id = 0;
-
-  if (priv->pending_activation_timeout_waiting_finger_off)
-    error = fpi_device_retry_new_msg (FP_DEVICE_RETRY_REMOVE_FINGER,
-                                      "Remove finger before requesting another scan operation");
-  else
-    error = fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL);
-
-  if (action == FPI_DEVICE_ACTION_VERIFY)
-    {
-      fpi_device_verify_report (device, FPI_MATCH_ERROR, NULL, error);
-      fpi_device_verify_complete (device, NULL);
-    }
-  else if (action == FPI_DEVICE_ACTION_IDENTIFY)
-    {
-      fpi_device_identify_report (device, NULL, NULL, error);
-      fpi_device_identify_complete (device, NULL);
-    }
-  else
-    {
-      /* Can this happen for enroll? */
-      fpi_device_action_error (device, error);
-    }
-
-  return G_SOURCE_REMOVE;
-}
-
 /* Callbacks/vfuncs */
 static void
 fp_image_device_open (FpDevice *device)
@@ -112,26 +74,14 @@ fp_image_device_close (FpDevice *device)
   FpImageDeviceClass *cls = FP_IMAGE_DEVICE_GET_CLASS (self);
   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
 
-  /* In the close case we may need to wait/force deactivation first.
+  g_assert (priv->active == FALSE);
-   * Three possible cases:
-   *  1. We are inactive
-   *     -> immediately close
-   *  2. We are waiting for finger off
-   *     -> immediately deactivate
-   *  3. We are deactivating
-   *     -> handled by deactivate_complete */
-
-  if (!priv->active)
   cls->img_close (self);
-  else if (priv->state != FPI_IMAGE_DEVICE_STATE_INACTIVE)
-    fpi_image_device_deactivate (self);
 }
 
 static void
 fp_image_device_cancel_action (FpDevice *device)
 {
   FpImageDevice *self = FP_IMAGE_DEVICE (device);
-  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
   FpiDeviceAction action;
 
   action = fpi_device_get_current_action (device);
@@ -142,17 +92,7 @@ fp_image_device_cancel_action (FpDevice *device)
       action == FPI_DEVICE_ACTION_VERIFY ||
       action == FPI_DEVICE_ACTION_IDENTIFY ||
       action == FPI_DEVICE_ACTION_CAPTURE)
-    {
+    fpi_image_device_deactivate (self, TRUE);
-      priv->cancelling = TRUE;
-      fpi_image_device_deactivate (self);
-      priv->cancelling = FALSE;
-
-      /* XXX: Some nicer way of doing this would be good. */
-      fpi_device_action_error (FP_DEVICE (self),
-                               g_error_new (G_IO_ERROR,
-                                            G_IO_ERROR_CANCELLED,
-                                            "Device operation was cancelled"));
-    }
 }
 
 static void
@@ -188,27 +128,9 @@ fp_image_device_start_capture_action (FpDevice *device)
     }
 
   priv->enroll_stage = 0;
-  priv->enroll_await_on_pending = FALSE;
+  /* The internal state machine guarantees both of these. */
-
+  g_assert (!priv->finger_present);
-  /* The device might still be deactivating from a previous call.
+  g_assert (!priv->minutiae_scan_active);
-   * In that situation, try to wait for a bit before reporting back an
-   * error (which will usually say that the user should remove the
-   * finger).
-   */
-  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 == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
-        priv->pending_activation_timeout_waiting_finger_off = TRUE;
-      else
-        priv->pending_activation_timeout_waiting_finger_off = FALSE;
-
-      return;
-    }
 
   /* And activate the device; we rely on fpi_image_device_activate_complete()
    * to be called when done (or immediately). */
@@ -225,7 +147,6 @@ fp_image_device_finalize (GObject *object)
   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
 
   g_assert (priv->active == FALSE);
-  g_clear_handle_id (&priv->pending_activation_timeout_id, g_source_remove);
 
   G_OBJECT_CLASS (fp_image_device_parent_class)->finalize (object);
 }

libfprint/fp-print.h

@@ -66,6 +66,18 @@ typedef enum {
   FP_FINGER_LAST = FP_FINGER_RIGHT_LITTLE,
 } FpFinger;
 
+/**
+ * FpFingerStatusFlags:
+ * @FP_FINGER_STATUS_NONE: Sensor has not the finger on it, nor requires it
+ * @FP_FINGER_STATUS_NEEDED: Sensor waits for the finger
+ * @FP_FINGER_STATUS_PRESENT: Sensor has the finger on it
+ */
+typedef enum {
+  FP_FINGER_STATUS_NONE    = 0,
+  FP_FINGER_STATUS_NEEDED  = 1 << 0,
+  FP_FINGER_STATUS_PRESENT = 1 << 1,
+} FpFingerStatusFlags;
+
 FpPrint *fp_print_new (FpDevice *device);
 
 FpPrint *fp_print_new_from_data (guchar *data,

libfprint/fpi-compat.h

@@ -37,3 +37,9 @@ typedef struct _FpDeviceClass FpDeviceClass;
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpDeviceClass, g_type_class_unref);
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (GDate, g_date_free);
 #endif
+
+#if  __GNUC__ > 10 || (__GNUC__ == 10 && __GNUC_MINOR__ >= 1)
+#define FP_GNUC_ACCESS(m, p, s) __attribute__((access (m, p, s)))
+#else
+#define FP_GNUC_ACCESS(m, p, s)
+#endif

libfprint/fpi-device.c

@@ -139,6 +139,10 @@ fpi_device_error_new (FpDeviceError error)
       msg = "This finger has already enrolled, please try a different finger";
       break;
 
+    case FP_DEVICE_ERROR_REMOVED:
+      msg = "This device has been removed from the system.";
+      break;
+
     default:
       g_warning ("Unsupported error, returning general error instead!");
       error = FP_DEVICE_ERROR_GENERAL;
@@ -576,6 +580,49 @@ fpi_device_get_cancellable (FpDevice *device)
   return g_task_get_cancellable (priv->current_task);
 }
 
+static void
+emit_removed_on_task_completed (FpDevice *device)
+{
+  g_signal_emit_by_name (device, "removed");
+}
+
+/**
+ * fpi_device_remove:
+ * @device: The #FpDevice
+ *
+ * Called to signal to the #FpDevice that it has been unplugged (physically
+ * removed from the system).
+ *
+ * For USB devices, this API is called automatically by #FpContext.
+ */
+void
+fpi_device_remove (FpDevice *device)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+
+  g_return_if_fail (FP_IS_DEVICE (device));
+  g_return_if_fail (!priv->is_removed);
+
+  priv->is_removed = TRUE;
+
+  g_object_notify (G_OBJECT (device), "removed");
+
+  /* If there is a pending action, we wait for it to fail, otherwise we
+   * immediately emit the "removed" signal. */
+  if (priv->current_task)
+    {
+      g_signal_connect_object (priv->current_task,
+                               "notify::completed",
+                               (GCallback) emit_removed_on_task_completed,
+                               device,
+                               G_CONNECT_SWAPPED);
+    }
+  else
+    {
+      g_signal_emit_by_name (device, "removed");
+    }
+}
+
 /**
  * fpi_device_action_error:
  * @device: The #FpDevice
@@ -691,6 +738,7 @@ fp_device_task_return_in_idle_cb (gpointer user_data)
   FpDeviceTaskReturnData *data = user_data;
   FpDevicePrivate *priv = fp_device_get_instance_private (data->device);
   g_autofree char *action_str = NULL;
+  FpiDeviceAction action;
 
   g_autoptr(GTask) task = NULL;
 
@@ -699,9 +747,24 @@ fp_device_task_return_in_idle_cb (gpointer user_data)
   g_debug ("Completing action %s in idle!", action_str);
 
   task = g_steal_pointer (&priv->current_task);
+  action = priv->current_action;
   priv->current_action = FPI_DEVICE_ACTION_NONE;
   priv->current_task_idle_return_source = NULL;
 
+  /* Return FP_DEVICE_ERROR_REMOVED if the device is removed,
+   * with the exception of a successful open, which is an odd corner case. */
+  if (priv->is_removed &&
+      ((action != FPI_DEVICE_ACTION_OPEN) ||
+       (action == FPI_DEVICE_ACTION_OPEN && data->type == FP_DEVICE_TASK_RETURN_ERROR)))
+    {
+      g_task_return_error (task, fpi_device_error_new (FP_DEVICE_ERROR_REMOVED));
+
+      /* NOTE: The removed signal will be emitted from the GTask
+       *       notify::completed if that is neccessary. */
+
+      return G_SOURCE_REMOVE;
+    }
+
   switch (data->type)
     {
     case FP_DEVICE_TASK_RETURN_INT:
@@ -713,16 +776,17 @@ fp_device_task_return_in_idle_cb (gpointer user_data)
       break;
 
     case FP_DEVICE_TASK_RETURN_OBJECT:
-      g_task_return_pointer (task, data->result, g_object_unref);
+      g_task_return_pointer (task, g_steal_pointer (&data->result),
+                             g_object_unref);
       break;
 
     case FP_DEVICE_TASK_RETURN_PTR_ARRAY:
-      g_task_return_pointer (task, data->result,
+      g_task_return_pointer (task, g_steal_pointer (&data->result),
                              (GDestroyNotify) g_ptr_array_unref);
       break;
 
     case FP_DEVICE_TASK_RETURN_ERROR:
-      g_task_return_error (task, data->result);
+      g_task_return_error (task, g_steal_pointer (&data->result));
       break;
 
     default:
@@ -735,6 +799,30 @@ fp_device_task_return_in_idle_cb (gpointer user_data)
 static void
 fpi_device_task_return_data_free (FpDeviceTaskReturnData *data)
 {
+  if (data->result)
+    {
+      switch (data->type)
+        {
+        case FP_DEVICE_TASK_RETURN_INT:
+        case FP_DEVICE_TASK_RETURN_BOOL:
+          break;
+
+        case FP_DEVICE_TASK_RETURN_OBJECT:
+          g_clear_object ((GObject **) &data->result);
+          break;
+
+        case FP_DEVICE_TASK_RETURN_PTR_ARRAY:
+          g_clear_pointer ((GPtrArray **) &data->result, g_ptr_array_unref);
+          break;
+
+        case FP_DEVICE_TASK_RETURN_ERROR:
+          g_clear_error ((GError **) &data->result);
+          break;
+
+        default:
+          g_assert_not_reached ();
+        }
+    }
   g_object_unref (data->device);
   g_free (data);
 }
@@ -787,6 +875,7 @@ fpi_device_probe_complete (FpDevice    *device,
   g_debug ("Device reported probe completion");
 
   clear_device_cancel_action (device);
+  fpi_device_report_finger_status (device, FP_FINGER_STATUS_NONE);
 
   if (!error)
     {
@@ -829,6 +918,7 @@ fpi_device_open_complete (FpDevice *device, GError *error)
   g_debug ("Device reported open completion");
 
   clear_device_cancel_action (device);
+  fpi_device_report_finger_status (device, FP_FINGER_STATUS_NONE);
 
   if (!error)
     {
@@ -862,6 +952,7 @@ fpi_device_close_complete (FpDevice *device, GError *error)
   g_debug ("Device reported close completion");
 
   clear_device_cancel_action (device);
+  fpi_device_report_finger_status (device, FP_FINGER_STATUS_NONE);
 
   switch (priv->type)
     {
@@ -885,18 +976,18 @@ fpi_device_close_complete (FpDevice *device, GError *error)
       return;
     }
 
-  if (!error)
+  /* Always consider the device closed. Drivers should try hard to close the
-    {
+   * device. Generally, e.g. cancellations should be ignored.
+   */
   priv->is_open = FALSE;
   g_object_notify (G_OBJECT (device), "open");
+
+  if (!error)
     fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_BOOL,
                                     GUINT_TO_POINTER (TRUE));
-    }
   else
-    {
     fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_ERROR, error);
 }
-}
 
 /**
  * fpi_device_enroll_complete:
@@ -918,12 +1009,14 @@ fpi_device_enroll_complete (FpDevice *device, FpPrint *print, GError *error)
   g_debug ("Device reported enroll completion");
 
   clear_device_cancel_action (device);
+  fpi_device_report_finger_status (device, FP_FINGER_STATUS_NONE);
 
   if (!error)
     {
       if (FP_IS_PRINT (print))
         {
           FpiPrintType print_type;
+          g_autofree char *finger_str = NULL;
 
           g_object_get (print, "fpi-type", &print_type, NULL);
           if (print_type == FPI_PRINT_UNDEFINED)
@@ -937,6 +1030,9 @@ fpi_device_enroll_complete (FpDevice *device, FpPrint *print, GError *error)
               return;
             }
 
+          finger_str = g_enum_to_string (FP_TYPE_FINGER, fp_print_get_finger (print));
+          g_debug ("Print for finger %s enrolled", finger_str);
+
           fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_OBJECT, print);
         }
       else
@@ -985,6 +1081,7 @@ fpi_device_verify_complete (FpDevice *device,
   data = g_task_get_task_data (priv->current_task);
 
   clear_device_cancel_action (device);
+  fpi_device_report_finger_status (device, FP_FINGER_STATUS_NONE);
 
   if (!error)
     {
@@ -1044,6 +1141,7 @@ fpi_device_identify_complete (FpDevice *device,
   data = g_task_get_task_data (priv->current_task);
 
   clear_device_cancel_action (device);
+  fpi_device_report_finger_status (device, FP_FINGER_STATUS_NONE);
 
   if (!error)
     {
@@ -1100,6 +1198,7 @@ fpi_device_capture_complete (FpDevice *device,
   g_debug ("Device reported capture completion");
 
   clear_device_cancel_action (device);
+  fpi_device_report_finger_status (device, FP_FINGER_STATUS_NONE);
 
   if (!error)
     {
@@ -1145,6 +1244,7 @@ fpi_device_delete_complete (FpDevice *device,
   g_debug ("Device reported deletion completion");
 
   clear_device_cancel_action (device);
+  fpi_device_report_finger_status (device, FP_FINGER_STATUS_NONE);
 
   if (!error)
     fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_BOOL,
@@ -1179,6 +1279,7 @@ fpi_device_list_complete (FpDevice  *device,
   g_debug ("Device reported listing completion");
 
   clear_device_cancel_action (device);
+  fpi_device_report_finger_status (device, FP_FINGER_STATUS_NONE);
 
   if (prints && error)
     {
@@ -1394,3 +1495,59 @@ fpi_device_identify_report (FpDevice *device,
   if (call_cb && data->match_cb)
     data->match_cb (device, data->match, data->print, data->match_data, data->error);
 }
+
+/**
+ * fpi_device_report_finger_status:
+ * @device: The #FpDevice
+ * @finger_status: The current #FpFingerStatusFlags to report
+ *
+ * Report the finger status for the @device.
+ * This can be used by UI to give a feedback
+ *
+ * Returns: %TRUE if changed
+ */
+gboolean
+fpi_device_report_finger_status (FpDevice           *device,
+                                 FpFingerStatusFlags finger_status)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+  g_autofree char *status_string = NULL;
+
+  if (priv->finger_status == finger_status)
+    return FALSE;
+
+  status_string = g_flags_to_string (FP_TYPE_FINGER_STATUS_FLAGS, finger_status);
+  fp_dbg ("Device reported finger status change: %s", status_string);
+
+  priv->finger_status = finger_status;
+  g_object_notify (G_OBJECT (device), "finger-status");
+
+  return TRUE;
+}
+
+/**
+ * fpi_device_report_finger_status_changes:
+ * @device: The #FpDevice
+ * @added_status: The #FpFingerStatusFlags to add
+ * @added_status: The #FpFingerStatusFlags to remove
+ *
+ * Report the finger status for the @device adding the @added_status flags
+ * and removing the @removed_status flags.
+ *
+ * This can be used by UI to give a feedback
+ *
+ * Returns: %TRUE if changed
+ */
+gboolean
+fpi_device_report_finger_status_changes (FpDevice           *device,
+                                         FpFingerStatusFlags added_status,
+                                         FpFingerStatusFlags removed_status)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+  FpFingerStatusFlags finger_status = priv->finger_status;
+
+  finger_status |= added_status;
+  finger_status &= ~removed_status;
+
+  return fpi_device_report_finger_status (device, finger_status);
+}

libfprint/fpi-device.h

@@ -202,6 +202,7 @@ void fpi_device_get_delete_data (FpDevice *device,
                                  FpPrint **print);
 GCancellable *fpi_device_get_cancellable (FpDevice *device);
 
+void fpi_device_remove (FpDevice *device);
 
 GSource * fpi_device_add_timeout (FpDevice      *device,
                                   gint           interval,
@@ -255,4 +256,10 @@ void fpi_device_identify_report (FpDevice *device,
                                  FpPrint  *print,
                                  GError   *error);
 
+gboolean fpi_device_report_finger_status (FpDevice           *device,
+                                          FpFingerStatusFlags finger_status);
+gboolean fpi_device_report_finger_status_changes (FpDevice           *device,
+                                                  FpFingerStatusFlags added_status,
+                                                  FpFingerStatusFlags removed_status);
+
 G_END_DECLS

libfprint/fpi-image-device.c

@@ -41,6 +41,9 @@ fp_image_device_get_instance_private (FpImageDevice *self)
                             g_type_class_get_instance_private_offset (img_class));
 }
 
+static void fp_image_device_change_state (FpImageDevice      *self,
+                                          FpiImageDeviceState state);
+
 /* Private shared functions */
 
 void
@@ -51,67 +54,105 @@ fpi_image_device_activate (FpImageDevice *self)
 
   g_assert (!priv->active);
 
-  /* We don't have a neutral ACTIVE state, but we always will
-   * go into WAIT_FINGER_ON afterwards. */
-  priv->state = FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON;
-  g_object_notify (G_OBJECT (self), "fpi-image-device-state");
-
-  /* We might have been waiting for deactivation to finish before
-   * starting the next operation. */
-  g_clear_handle_id (&priv->pending_activation_timeout_id, g_source_remove);
-
   fp_dbg ("Activating image device");
+  fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_ACTIVATING);
   cls->activate (self);
 }
 
 void
-fpi_image_device_deactivate (FpImageDevice *self)
+fpi_image_device_deactivate (FpImageDevice *self, gboolean cancelling)
 {
   FpDevice *device = FP_DEVICE (self);
   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
   FpImageDeviceClass *cls = FP_IMAGE_DEVICE_GET_CLASS (device);
 
-  if (!priv->active || priv->state == FPI_IMAGE_DEVICE_STATE_INACTIVE)
+  if (!priv->active || priv->state == FPI_IMAGE_DEVICE_STATE_DEACTIVATING)
     {
       /* XXX: We currently deactivate both from minutiae scan result
        *      and finger off report. */
       fp_dbg ("Already deactivated, ignoring request.");
       return;
     }
-  if (!priv->cancelling && priv->state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
+  if (!cancelling && priv->state != FPI_IMAGE_DEVICE_STATE_IDLE)
-    g_warning ("Deactivating image device while waiting for finger, this should not happen.");
+    g_warning ("Deactivating image device while it is not idle, this should not happen.");
-
-  priv->state = FPI_IMAGE_DEVICE_STATE_INACTIVE;
-  g_object_notify (G_OBJECT (self), "fpi-image-device-state");
 
   fp_dbg ("Deactivating image device");
+  fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_DEACTIVATING);
   cls->deactivate (self);
 }
 
 /* Static helper functions */
 
+/* This should not be called directly to activate/deactivate the device! */
 static void
 fp_image_device_change_state (FpImageDevice *self, FpiImageDeviceState state)
 {
   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
   g_autofree char *prev_state_str = NULL;
   g_autofree char *state_str = NULL;
+  gboolean transition_is_valid = FALSE;
+  gint i;
 
-  /* Cannot change to inactive using this function. */
+  struct
-  g_assert (state != FPI_IMAGE_DEVICE_STATE_INACTIVE);
+  {
+    FpiImageDeviceState from;
+    FpiImageDeviceState to;
+  } valid_transitions[] = {
+    { FPI_IMAGE_DEVICE_STATE_INACTIVE, FPI_IMAGE_DEVICE_STATE_ACTIVATING },
 
-  /* We might have been waiting for the finger to go OFF to start the
+    { FPI_IMAGE_DEVICE_STATE_ACTIVATING, FPI_IMAGE_DEVICE_STATE_IDLE },
-   * next operation. */
+    { FPI_IMAGE_DEVICE_STATE_ACTIVATING, FPI_IMAGE_DEVICE_STATE_INACTIVE },
-  g_clear_handle_id (&priv->pending_activation_timeout_id, g_source_remove);
+
+    { FPI_IMAGE_DEVICE_STATE_IDLE, FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON },
+    { FPI_IMAGE_DEVICE_STATE_IDLE, FPI_IMAGE_DEVICE_STATE_CAPTURE }, /* raw mode -- currently not supported */
+    { FPI_IMAGE_DEVICE_STATE_IDLE, FPI_IMAGE_DEVICE_STATE_DEACTIVATING },
+
+    { FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON, FPI_IMAGE_DEVICE_STATE_CAPTURE },
+    { FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON, FPI_IMAGE_DEVICE_STATE_DEACTIVATING }, /* cancellation */
+
+    { FPI_IMAGE_DEVICE_STATE_CAPTURE, FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF },
+    { FPI_IMAGE_DEVICE_STATE_CAPTURE, FPI_IMAGE_DEVICE_STATE_IDLE }, /* raw mode -- currently not supported */
+    { FPI_IMAGE_DEVICE_STATE_CAPTURE, FPI_IMAGE_DEVICE_STATE_DEACTIVATING }, /* cancellation */
+
+    { FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF, FPI_IMAGE_DEVICE_STATE_IDLE },
+    { FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF, FPI_IMAGE_DEVICE_STATE_DEACTIVATING }, /* cancellation */
+
+    { FPI_IMAGE_DEVICE_STATE_DEACTIVATING, FPI_IMAGE_DEVICE_STATE_INACTIVE },
+  };
 
   prev_state_str = g_enum_to_string (FPI_TYPE_IMAGE_DEVICE_STATE, priv->state);
   state_str = g_enum_to_string (FPI_TYPE_IMAGE_DEVICE_STATE, state);
   fp_dbg ("Image device internal state change from %s to %s",
           prev_state_str, state_str);
 
+  for (i = 0; i < G_N_ELEMENTS (valid_transitions); i++)
+    {
+      if (valid_transitions[i].from == priv->state && valid_transitions[i].to == state)
+        {
+          transition_is_valid = TRUE;
+          break;
+        }
+    }
+  if (!transition_is_valid)
+    g_warning ("Internal state machine issue: transition from %s to %s should not happen!",
+               prev_state_str, state_str);
+
   priv->state = state;
   g_object_notify (G_OBJECT (self), "fpi-image-device-state");
   g_signal_emit_by_name (self, "fpi-image-device-state-changed", priv->state);
+
+  if (state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
+    {
+      fpi_device_report_finger_status_changes (FP_DEVICE (self),
+                                               FP_FINGER_STATUS_NEEDED,
+                                               FP_FINGER_STATUS_NONE);
+    }
+  else if (state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
+    {
+      fpi_device_report_finger_status_changes (FP_DEVICE (self),
+                                               FP_FINGER_STATUS_NONE,
+                                               FP_FINGER_STATUS_NEEDED);
+    }
 }
 
 static void
@@ -119,15 +160,75 @@ fp_image_device_enroll_maybe_await_finger_on (FpImageDevice *self)
 {
   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
 
-  if (priv->enroll_await_on_pending)
+  /* We wait for both the minutiae scan to complete and the finger to
-    {
+   * be removed before we switch to AWAIT_FINGER_ON. */
-      priv->enroll_await_on_pending = FALSE;
+  if (priv->minutiae_scan_active || priv->finger_present)
+    return;
+
   fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON);
 }
+
+static void
+fp_image_device_maybe_complete_action (FpImageDevice *self, GError *error)
+{
+  FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
+  FpDevice *device = FP_DEVICE (self);
+  FpiDeviceAction action;
+
+  if (error)
+    {
+      /* Keep the first error we encountered, but not if it is of type retry */
+      if (priv->action_error && !(priv->action_error->domain == FP_DEVICE_RETRY))
+        {
+          g_warning ("Will complete with first error, new error was: %s", error->message);
+          g_clear_error (&error);
+        }
       else
         {
-      fp_dbg ("Awaiting finger on");
+          g_clear_error (&priv->action_error);
-      priv->enroll_await_on_pending = TRUE;
+          priv->action_error = error;
+        }
+    }
+
+  /* Do not complete if the device is still active or a minutiae scan is pending. */
+  if (priv->active || priv->minutiae_scan_active)
+    return;
+
+  if (!priv->action_error)
+    g_cancellable_set_error_if_cancelled (fpi_device_get_cancellable (device), &priv->action_error);
+
+  if (priv->action_error)
+    {
+      fpi_device_action_error (device, g_steal_pointer (&priv->action_error));
+      g_clear_object (&priv->capture_image);
+      return;
+    }
+
+  /* We are done, report the result. */
+  action = fpi_device_get_current_action (FP_DEVICE (self));
+
+  if (action == FPI_DEVICE_ACTION_ENROLL)
+    {
+      FpPrint *enroll_print;
+      fpi_device_get_enroll_data (device, &enroll_print);
+
+      fpi_device_enroll_complete (device, g_object_ref (enroll_print), NULL);
+    }
+  else if (action == FPI_DEVICE_ACTION_VERIFY)
+    {
+      fpi_device_verify_complete (device, NULL);
+    }
+  else if (action == FPI_DEVICE_ACTION_IDENTIFY)
+    {
+      fpi_device_identify_complete (device, NULL);
+    }
+  else if (action == FPI_DEVICE_ACTION_CAPTURE)
+    {
+      fpi_device_capture_complete (device, g_steal_pointer (&priv->capture_image), NULL);
+    }
+  else
+    {
+      g_assert_not_reached ();
     }
 }
 
@@ -143,14 +244,16 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
   FpiDeviceAction action;
 
   /* Note: We rely on the device to not disappear during an operation. */
+  priv = fp_image_device_get_instance_private (FP_IMAGE_DEVICE (device));
+  priv->minutiae_scan_active = FALSE;
 
   if (!fp_image_detect_minutiae_finish (image, res, &error))
     {
       /* Cancel operation . */
       if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
         {
-          fpi_device_action_error (device, g_steal_pointer (&error));
+          fp_image_device_maybe_complete_action (self, g_steal_pointer (&error));
-          fpi_image_device_deactivate (self);
+          fpi_image_device_deactivate (self, TRUE);
           return;
         }
 
@@ -161,13 +264,12 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
       error = fpi_device_retry_new_msg (FP_DEVICE_RETRY_GENERAL, "Minutiae detection failed, please retry");
     }
 
-  priv = fp_image_device_get_instance_private (FP_IMAGE_DEVICE (device));
   action = fpi_device_get_current_action (device);
 
   if (action == FPI_DEVICE_ACTION_CAPTURE)
     {
-      fpi_device_capture_complete (device, g_steal_pointer (&image), error);
+      priv->capture_image = g_steal_pointer (&image);
-      fpi_image_device_deactivate (self);
+      fp_image_device_maybe_complete_action (self, g_steal_pointer (&error));
       return;
     }
 
@@ -181,8 +283,9 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
 
           if (error->domain != FP_DEVICE_RETRY)
             {
-              fpi_device_action_error (device, error);
+              fp_image_device_maybe_complete_action (self, g_steal_pointer (&error));
-              fpi_image_device_deactivate (self);
+              /* We might not yet be deactivating, if we are enrolling. */
+              fpi_image_device_deactivate (self, TRUE);
               return;
             }
         }
@@ -205,8 +308,8 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
       /* Start another scan or deactivate. */
       if (priv->enroll_stage == IMG_ENROLL_STAGES)
         {
-          fpi_device_enroll_complete (device, g_object_ref (enroll_print), NULL);
+          fp_image_device_maybe_complete_action (self, g_steal_pointer (&error));
-          fpi_image_device_deactivate (self);
+          fpi_image_device_deactivate (self, FALSE);
         }
       else
         {
@@ -226,8 +329,8 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
 
       if (!error || error->domain == FP_DEVICE_RETRY)
         fpi_device_verify_report (device, result, g_steal_pointer (&print), g_steal_pointer (&error));
-      fpi_device_verify_complete (device, error);
+
-      fpi_image_device_deactivate (self);
+      fp_image_device_maybe_complete_action (self, g_steal_pointer (&error));
     }
   else if (action == FPI_DEVICE_ACTION_IDENTIFY)
     {
@@ -249,8 +352,8 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
 
       if (!error || error->domain == FP_DEVICE_RETRY)
         fpi_device_identify_report (device, result, g_steal_pointer (&print), g_steal_pointer (&error));
-      fpi_device_identify_complete (device, error);
+
-      fpi_image_device_deactivate (self);
+      fp_image_device_maybe_complete_action (self, g_steal_pointer (&error));
     }
   else
     {
@@ -305,6 +408,19 @@ fpi_image_device_report_finger_status (FpImageDevice *self,
   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
   FpiDeviceAction action;
 
+  if (present)
+    {
+      fpi_device_report_finger_status_changes (device,
+                                               FP_FINGER_STATUS_PRESENT,
+                                               FP_FINGER_STATUS_NONE);
+    }
+  else
+    {
+      fpi_device_report_finger_status_changes (device,
+                                               FP_FINGER_STATUS_NONE,
+                                               FP_FINGER_STATUS_PRESENT);
+    }
+
   if (priv->state == FPI_IMAGE_DEVICE_STATE_INACTIVE)
     {
       /* Do we really want to always ignore such reports? We could
@@ -323,27 +439,23 @@ fpi_image_device_report_finger_status (FpImageDevice *self,
 
   g_debug ("Image device reported finger status: %s", present ? "on" : "off");
 
+  priv->finger_present = present;
+
   if (present && priv->state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
     {
       fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_CAPTURE);
     }
   else if (!present && priv->state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF)
     {
-      /* We need to deactivate or continue to await finger */
+      /* If we are in the non-enroll case, we always deactivate.
-
-      /* There are three possible situations:
-       *  1. We are deactivating the device and the action is still in progress
-       *     (minutiae detection).
-       *  2. We are still deactivating the device after an action completed
-       *  3. We were waiting for finger removal to start the new action
-       * Either way, we always end up deactivating except for the enroll case.
        *
-       * The enroll case is special as AWAIT_FINGER_ON should only happen after
+       * In the enroll case, the decision can only be made after minutiae
-       * minutiae detection to prevent deactivation (without cancellation)
+       * detection has finished.
-       * from the AWAIT_FINGER_ON state.
        */
+      fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_IDLE);
+
       if (action != FPI_DEVICE_ACTION_ENROLL)
-        fpi_image_device_deactivate (self);
+        fpi_image_device_deactivate (self, FALSE);
       else
         fp_image_device_enroll_maybe_await_finger_on (self);
     }
@@ -378,16 +490,19 @@ fpi_image_device_image_captured (FpImageDevice *self, FpImage *image)
                     action == FPI_DEVICE_ACTION_IDENTIFY ||
                     action == FPI_DEVICE_ACTION_CAPTURE);
 
-  fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF);
-
   g_debug ("Image device captured an image");
 
+  priv->minutiae_scan_active = TRUE;
+
   /* XXX: We also detect minutiae in capture mode, we solely do this
    *      to normalize the image which will happen as a by-product. */
   fp_image_detect_minutiae (image,
                             fpi_device_get_cancellable (FP_DEVICE (self)),
                             fpi_image_device_minutiae_detected,
                             self);
+
+  /* XXX: This is wrong if we add support for raw capture mode. */
+  fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF);
 }
 
 /**
@@ -423,36 +538,27 @@ fpi_image_device_retry_scan (FpImageDevice *self, FpDeviceRetry retry)
       g_debug ("Reporting retry during enroll");
       fpi_device_enroll_progress (FP_DEVICE (self), priv->enroll_stage, NULL, error);
 
-      /* Wait for finger removal and re-touch.
-       * TODO: Do we need to check that the finger is already off? */
-      priv->enroll_await_on_pending = TRUE;
       fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF);
     }
   else if (action == FPI_DEVICE_ACTION_VERIFY)
     {
       fpi_device_verify_report (FP_DEVICE (self), FPI_MATCH_ERROR, NULL, error);
-      priv->cancelling = TRUE;
+      fp_image_device_maybe_complete_action (self, NULL);
-      fpi_image_device_deactivate (self);
+      fpi_image_device_deactivate (self, TRUE);
-      priv->cancelling = FALSE;
+
-      fpi_device_verify_complete (FP_DEVICE (self), NULL);
     }
   else if (action == FPI_DEVICE_ACTION_IDENTIFY)
     {
       fpi_device_identify_report (FP_DEVICE (self), NULL, NULL, error);
-      priv->cancelling = TRUE;
+      fp_image_device_maybe_complete_action (self, NULL);
-      fpi_image_device_deactivate (self);
+      fpi_image_device_deactivate (self, TRUE);
-      priv->cancelling = FALSE;
-      fpi_device_identify_complete (FP_DEVICE (self), NULL);
     }
   else
     {
-      /* We abort the operation and let the surrounding code retry in the
+      /* The capture case where there is no early reporting. */
-       * non-enroll case (this is identical to a session error). */
+      g_debug ("Abort current operation due to retry (no early-reporting)");
-      g_debug ("Abort current operation due to retry (non-enroll case)");
+      fp_image_device_maybe_complete_action (self, error);
-      priv->cancelling = TRUE;
+      fpi_image_device_deactivate (self, TRUE);
-      fpi_image_device_deactivate (self);
-      priv->cancelling = FALSE;
-      fpi_device_action_error (FP_DEVICE (self), error);
     }
 }
 
@@ -511,10 +617,8 @@ fpi_image_device_session_error (FpImageDevice *self, GError *error)
   if (error->domain == FP_DEVICE_RETRY)
     g_warning ("Driver should report retries using fpi_image_device_retry_scan!");
 
-  priv->cancelling = TRUE;
+  fp_image_device_maybe_complete_action (self, error);
-  fpi_image_device_deactivate (self);
+  fpi_image_device_deactivate (self, TRUE);
-  priv->cancelling = FALSE;
-  fpi_device_action_error (FP_DEVICE (self), error);
 }
 
 /**
@@ -533,6 +637,7 @@ fpi_image_device_activate_complete (FpImageDevice *self, GError *error)
   action = fpi_device_get_current_action (FP_DEVICE (self));
 
   g_return_if_fail (priv->active == FALSE);
+  g_return_if_fail (priv->state == FPI_IMAGE_DEVICE_STATE_ACTIVATING);
   g_return_if_fail (action == FPI_DEVICE_ACTION_ENROLL ||
                     action == FPI_DEVICE_ACTION_VERIFY ||
                     action == FPI_DEVICE_ACTION_IDENTIFY ||
@@ -551,6 +656,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, FPI_IMAGE_DEVICE_STATE_IDLE);
   fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON);
 }
 
@@ -565,36 +671,20 @@ void
 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);
-  FpiDeviceAction action;
 
   g_return_if_fail (priv->active == TRUE);
-  g_return_if_fail (priv->state == FPI_IMAGE_DEVICE_STATE_INACTIVE);
+  g_return_if_fail (priv->state == FPI_IMAGE_DEVICE_STATE_DEACTIVATING);
 
   g_debug ("Image device deactivation completed");
 
   priv->active = FALSE;
 
-  /* Deactivation completed. As we deactivate in the background
+  /* Assume finger was removed. */
-   * there may already be a new task pending. Check whether we
+  priv->finger_present = FALSE;
-   * need to do anything. */
-  action = fpi_device_get_current_action (FP_DEVICE (self));
 
-  /* Special case, if we should be closing, but didn't due to a running
+  fp_image_device_change_state (self, FPI_IMAGE_DEVICE_STATE_INACTIVE);
-   * deactivation, then do so now. */
-  if (action == FPI_DEVICE_ACTION_CLOSE)
-    {
-      cls->img_close (self);
-      return;
-    }
 
-  /* We might be waiting to be able to activate again. */
+  fp_image_device_maybe_complete_action (self, error);
-  if (priv->pending_activation_timeout_id)
-    {
-      g_clear_handle_id (&priv->pending_activation_timeout_id, g_source_remove);
-      priv->pending_activation_timeout_id =
-        g_idle_add ((GSourceFunc) fpi_image_device_activate, self);
-    }
 }
 
 /**
@@ -620,6 +710,8 @@ fpi_image_device_open_complete (FpImageDevice *self, GError *error)
   priv->state = FPI_IMAGE_DEVICE_STATE_INACTIVE;
   g_object_notify (G_OBJECT (self), "fpi-image-device-state");
 
+  fpi_device_report_finger_status (FP_DEVICE (self), FP_FINGER_STATUS_NONE);
+
   fpi_device_open_complete (FP_DEVICE (self), error);
 }
 

libfprint/fpi-image-device.h

@@ -25,6 +25,9 @@
 /**
  * FpiImageDeviceState:
  * @FPI_IMAGE_DEVICE_STATE_INACTIVE: inactive
+ * @FPI_IMAGE_DEVICE_STATE_ACTIVATING: State during activate callback
+ * @FPI_IMAGE_DEVICE_STATE_IDLE: Activated but idle
+ * @FPI_IMAGE_DEVICE_STATE_DEACTIVATING: State during deactivate callback
  * @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
@@ -35,9 +38,33 @@
  * The driver needs to call fpi_image_device_report_finger_status() to move
  * between the different states. Note that the capture state might be entered
  * unconditionally if the device supports raw capturing.
+ *
+ * A usual run would look like:
+ *  - inactive -> activating: activate vfunc is called
+ *  - activating -> idle: fpi_image_device_activate_complete()
+ *  - idle -> await-finger-on
+ *  - await-finger-on -> capture: fpi_image_device_report_finger_status()
+ *  - capture -> await-finger-off: fpi_image_device_image_captured()
+ *  - await-finger-off -> idle: fpi_image_device_report_finger_status()
+ *  - idle -> deactivating: deactivate vfunc is called
+ *  - deactivating -> inactive: fpi_image_device_deactivate_complete()
+ *
+ * Raw mode is currently not supported (not waiting for finger), but in that
+ * case the following transitions are valid:
+ *  - idle -> capture
+ *  - capture -> idle
+ *
+ * Also valid are these transitions in case of errors or cancellations:
+ *  - activating -> inactive: fpi_image_device_activate_complete()
+ *  - await-finger-on -> deactivating: deactivate vfunc is called
+ *  - capture -> deactivating: deactivate vfunc is called
+ *  - await-finger-off -> deactivating: deactivate vfunc is called
  */
 typedef enum {
   FPI_IMAGE_DEVICE_STATE_INACTIVE,
+  FPI_IMAGE_DEVICE_STATE_ACTIVATING,
+  FPI_IMAGE_DEVICE_STATE_DEACTIVATING,
+  FPI_IMAGE_DEVICE_STATE_IDLE,
   FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON,
   FPI_IMAGE_DEVICE_STATE_CAPTURE,
   FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF,
@@ -58,11 +85,6 @@ typedef enum {
  *   finger or image capture). Implementing this is optional, it can e.g. be
  *   used to flash an LED when waiting for a finger.
  *
- * These are the main entry points for image based drivers. For all but the
- * change_state vfunc, implementations *must* eventually call the corresponding
- * function to finish the operation. It is also acceptable to call the generic
- *
- *
  * These are the main entry points for drivers to implement. Drivers may not
  * implement all of these entry points if they do not support the operation
  * (or a default implementation is sufficient).

libfprint/fpi-usb-transfer.c

@@ -354,6 +354,24 @@ transfer_finish_cb (GObject *source_object, GAsyncResult *res, gpointer user_dat
   fpi_usb_transfer_unref (transfer);
 }
 
+static gboolean
+transfer_cancel_cb (FpiUsbTransfer *transfer)
+{
+  GError *error;
+  FpiUsbTransferCallback callback;
+
+  error = g_error_new_literal (G_IO_ERROR,
+                               G_IO_ERROR_CANCELLED,
+                               "Transfer was cancelled before being started");
+  callback = transfer->callback;
+  transfer->callback = NULL;
+  transfer->actual_length = -1;
+  callback (transfer, transfer->device, transfer->user_data, error);
+
+  fpi_usb_transfer_unref (transfer);
+
+  return G_SOURCE_REMOVE;
+}
 
 /**
  * fpi_usb_transfer_submit:
@@ -387,6 +405,18 @@ fpi_usb_transfer_submit (FpiUsbTransfer        *transfer,
 
   log_transfer (transfer, TRUE, NULL);
 
+  /* Work around libgusb cancellation issue, see
+   *   https://github.com/hughsie/libgusb/pull/42
+   * should be fixed with libgusb 0.3.7.
+   * Note that this is not race free, we rely on libfprint and API users
+   * not cancelling from a different thread here.
+   */
+  if (cancellable && g_cancellable_is_cancelled (cancellable))
+    {
+      g_idle_add ((GSourceFunc) transfer_cancel_cb, transfer);
+      return;
+    }
+
   switch (transfer->type)
     {
     case FP_TRANSFER_BULK:

libfprint/fpi-usb-transfer.h

@@ -20,6 +20,7 @@
 #pragma once
 
 #include <gusb.h>
+#include "fpi-compat.h"
 #include "fpi-device.h"
 
 G_BEGIN_DECLS
@@ -115,6 +116,7 @@ void               fpi_usb_transfer_fill_bulk (FpiUsbTransfer *transfer,
                                                guint8          endpoint,
                                                gsize           length);
 
+FP_GNUC_ACCESS (read_only, 3, 4)
 void               fpi_usb_transfer_fill_bulk_full (FpiUsbTransfer *transfer,
                                                     guint8          endpoint,
                                                     guint8         *buffer,
@@ -134,6 +136,7 @@ void               fpi_usb_transfer_fill_interrupt (FpiUsbTransfer *transfer,
                                                     guint8          endpoint,
                                                     gsize           length);
 
+FP_GNUC_ACCESS (read_only, 3, 4)
 void               fpi_usb_transfer_fill_interrupt_full (FpiUsbTransfer *transfer,
                                                          guint8          endpoint,
                                                          guint8         *buffer,

libfprint/fprint-list-udev-rules.c

@@ -25,11 +25,78 @@
 #include "fpi-device.h"
 
 static const FpIdEntry whitelist_id_table[] = {
-  /* Unsupported (for now) Validity Sensors finger print readers */
+  /* Currently known and unsupported devices.
-  { .vid = 0x138a, .pid = 0x0090 },   /* Found on e.g. Lenovo T460s */
+   * You can generate this list from the wiki page using e.g.:
+   *   gio cat https://gitlab.freedesktop.org/libfprint/wiki/-/wikis/Unsupported-Devices.md | sed -n 's!|.*\([0-9a-fA-F]\{4\}\):\([0-9a-fA-F]\{4\}\).*|.*!  { .vid = 0x\1, .pid = 0x\2 },!p'
+   */
+  { .vid = 0x04f3, .pid = 0x036b },
+  { .vid = 0x04f3, .pid = 0x0c00 },
+  { .vid = 0x04f3, .pid = 0x0c4b },
+  { .vid = 0x04f3, .pid = 0x0c4c },
+  { .vid = 0x04f3, .pid = 0x0c4f },
+  { .vid = 0x04f3, .pid = 0x0c57 },
+  { .vid = 0x04f3, .pid = 0x2706 },
+  { .vid = 0x06cb, .pid = 0x0081 },
+  { .vid = 0x06cb, .pid = 0x0088 },
+  { .vid = 0x06cb, .pid = 0x008a },
+  { .vid = 0x06cb, .pid = 0x009a },
+  { .vid = 0x06cb, .pid = 0x009b },
+  { .vid = 0x06cb, .pid = 0x00a2 },
+  { .vid = 0x06cb, .pid = 0x00b7 },
+  { .vid = 0x06cb, .pid = 0x00bb },
+  { .vid = 0x06cb, .pid = 0x00be },
+  { .vid = 0x06cb, .pid = 0x00c2 },
+  { .vid = 0x06cb, .pid = 0x00c9 },
+  { .vid = 0x06cb, .pid = 0x00cb },
+  { .vid = 0x06cb, .pid = 0x00d8 },
+  { .vid = 0x06cb, .pid = 0x00da },
+  { .vid = 0x06cb, .pid = 0x00e7 },
+  { .vid = 0x0a5c, .pid = 0x5801 },
+  { .vid = 0x0a5c, .pid = 0x5805 },
+  { .vid = 0x0a5c, .pid = 0x5834 },
+  { .vid = 0x0a5c, .pid = 0x5843 },
+  { .vid = 0x10a5, .pid = 0x0007 },
+  { .vid = 0x1188, .pid = 0x9545 },
+  { .vid = 0x138a, .pid = 0x0007 },
+  { .vid = 0x138a, .pid = 0x003a },
+  { .vid = 0x138a, .pid = 0x003c },
+  { .vid = 0x138a, .pid = 0x003d },
+  { .vid = 0x138a, .pid = 0x003f },
+  { .vid = 0x138a, .pid = 0x0090 },
   { .vid = 0x138a, .pid = 0x0091 },
+  { .vid = 0x138a, .pid = 0x0092 },
   { .vid = 0x138a, .pid = 0x0094 },
-  { .vid = 0x138a, .pid = 0x0097 },   /* Found on e.g. Lenovo T470s */
+  { .vid = 0x138a, .pid = 0x0097 },
+  { .vid = 0x138a, .pid = 0x009d },
+  { .vid = 0x138a, .pid = 0x00ab },
+  { .vid = 0x147e, .pid = 0x1002 },
+  { .vid = 0x1491, .pid = 0x0088 },
+  { .vid = 0x16d1, .pid = 0x1027 },
+  { .vid = 0x1c7a, .pid = 0x0300 },
+  { .vid = 0x1c7a, .pid = 0x0570 },
+  { .vid = 0x1c7a, .pid = 0x0575 },
+  { .vid = 0x27c6, .pid = 0x5042 },
+  { .vid = 0x27c6, .pid = 0x5110 },
+  { .vid = 0x27c6, .pid = 0x5117 },
+  { .vid = 0x27c6, .pid = 0x5201 },
+  { .vid = 0x27c6, .pid = 0x521d },
+  { .vid = 0x27c6, .pid = 0x5301 },
+  { .vid = 0x27c6, .pid = 0x530c },
+  { .vid = 0x27c6, .pid = 0x532d },
+  { .vid = 0x27c6, .pid = 0x533c },
+  { .vid = 0x27c6, .pid = 0x5381 },
+  { .vid = 0x27c6, .pid = 0x5385 },
+  { .vid = 0x27c6, .pid = 0x538c },
+  { .vid = 0x27c6, .pid = 0x538d },
+  { .vid = 0x27c6, .pid = 0x5395 },
+  { .vid = 0x27c6, .pid = 0x5584 },
+  { .vid = 0x27c6, .pid = 0x55a2 },
+  { .vid = 0x27c6, .pid = 0x55a4 },
+  { .vid = 0x27c6, .pid = 0x55b4 },
+  { .vid = 0x27c6, .pid = 0x5740 },
+  { .vid = 0x2808, .pid = 0x9338 },
+  { .vid = 0x298d, .pid = 0x2033 },
+  { .vid = 0x3538, .pid = 0x0930 },
   { .vid = 0 },
 };
 

meson.build

@@ -1,5 +1,5 @@
 project('libfprint', [ 'c', 'cpp' ],
-    version: '1.90.3',
+    version: '1.90.5',
     license: 'LGPLv2.1+',
     default_options: [
         'buildtype=debugoptimized',

tests/README-umockdev

@@ -1,53 +0,0 @@
-To create a new umockdev test, you should:
-
- 1. Decide on what to test, the easiest case is just using the existing
-    capture test case.
- 2. Find the USB device you are testing with lsusb, e.g.:
-     Bus 001 Device 005: ID 138a:0090 Validity Sensors, Inc. VFS7500 Touch Fingerprint Sensor
-    This means we need to record USB device /dev/bus/usb/001/005
- 3. Run "umockdev-record /dev/bus/usb/001/005 >device"
-    This records the information about device, it should be placed into test/DRIVER/device
- 4. Run the test, for a capture test this would be:
-      umockdev-record -i /dev/bus/usb/001/005=capture.ioctl -- ./capture.py capture.png
-    This will create a capture.ioctl and capture.png file.
-    Please set the FP_DEVICE_EMULATION=1 environment variable. You may need
-    to adjust the driver to adapt to the emulated environment (mainly if it
-    uses random numbers, see synaptics.c for an example).
- 5. Place all files into the driver subdirectory test/DRIVER,
-    i.e. device, capture.ioctl, capture.png
- 6. Add glue to meson.build
- 7. Test whether everything works as expected
-
-Please note, there is no need to use a real finger print in this case. If
-you would like to avoid submitting your own fingerprint then please just
-use e.g. the side of your finger, arm, or anything else that will produce
-an image with the device.
-
-
-Note that umockdev-record groups URBs aggressively. In most cases, manual
-intervention is unfortunately required. In most cases, drivers do a chain
-of commands like e.g. A then B each with a different reply. Umockdev will
-create a file like:
-
-A
- reply 1
- reply 2
-B
- reply 1
- reply 2
-
-which then needs to be re-ordered to be:
-
-A
- reply 1
-B
- reply 1
-A
- reply 2
-B
- reply 2
-
-Other changes may be needed to get everything working. For example the elan
-driver relies on a timeout that is not reported correctly. In this case the
-driver works around it by interpreting the protocol error differently in
-the virtual environment.

tests/meson.build

@@ -21,6 +21,7 @@ drivers_tests = [
     'elan',
     'synaptics',
     'vfs0050',
+    'vfs301',
     'vfs5011',
     'goodixmoc',
 ]

tests/synaptics/custom.py

@@ -20,11 +20,14 @@ d.open_sync()
 template = FPrint.Print.new(d)
 
 def enroll_progress(*args):
+    assert d.get_finger_status() == FPrint.FingerStatusFlags.NEEDED
     print('enroll progress: ' + str(args))
 
 # List, enroll, list, verify, delete, list
 print("enrolling")
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
 p = d.enroll_sync(template, None, enroll_progress, None)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
 print("enroll done")
 
 print("listing")
@@ -33,7 +36,9 @@ print("listing done")
 assert len(stored) == 1
 assert stored[0].equal(p)
 print("verifying")
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
 verify_res, verify_print = d.verify_sync(p)
+assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
 print("verify done")
 assert verify_res == True
 

tests/test-fp-context.c

@@ -20,6 +20,7 @@
 #include <libfprint/fprint.h>
 
 #include "test-utils.h"
+#include "fpi-device.h"
 
 static void
 test_context_new (void)
@@ -92,6 +93,296 @@ test_context_enumerates_new_devices (void)
   fpt_teardown_virtual_device_environment ();
 }
 
+#define DEV_REMOVED_CB 1
+#define CTX_DEVICE_REMOVED_CB 2
+
+static void
+device_removed_cb (FpDevice *device, FptContext *tctx)
+{
+  g_assert_nonnull (device);
+  g_assert_true (device == tctx->device);
+
+  g_assert_null (tctx->user_data);
+  tctx->user_data = GINT_TO_POINTER (DEV_REMOVED_CB);
+}
+
+static void
+context_device_removed_cb (FpContext *ctx, FpDevice *device, FptContext *tctx)
+{
+  g_assert_nonnull (device);
+  g_assert_true (device == tctx->device);
+
+  /* "device-removed" on context is always after "removed" on device */
+  g_assert_cmpint (GPOINTER_TO_INT (tctx->user_data), ==, DEV_REMOVED_CB);
+  tctx->user_data = GINT_TO_POINTER (CTX_DEVICE_REMOVED_CB);
+}
+
+static void
+test_context_remove_device_closed (void)
+{
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  gboolean removed;
+
+  tctx->user_data = NULL;
+  g_signal_connect (tctx->device, "removed", (GCallback) device_removed_cb, tctx);
+  g_signal_connect (tctx->fp_context, "device-removed", (GCallback) context_device_removed_cb, tctx);
+
+  /* Triggering remove on closed device. */
+  fpi_device_remove (tctx->device);
+
+  g_assert_nonnull (tctx->device);
+  g_object_get (tctx->device, "removed", &removed, NULL);
+  g_assert_true (removed);
+  g_assert_cmpint (GPOINTER_TO_INT (tctx->user_data), ==, DEV_REMOVED_CB);
+
+  /* device-removed is dispatched from idle. */
+  while (g_main_context_iteration (NULL, FALSE))
+    {
+    }
+
+  /* The device is now destroyed and device-removed was called. */
+  g_assert_null (tctx->device);
+  g_assert_cmpint (GPOINTER_TO_INT (tctx->user_data), ==, CTX_DEVICE_REMOVED_CB);
+
+  fpt_teardown_virtual_device_environment ();
+}
+
+static void
+close_done_cb (GObject *device, GAsyncResult *res, gpointer user_data)
+{
+  g_autoptr(FpPrint) print = NULL;
+  GError **error = user_data;
+
+  g_assert_nonnull (error);
+  g_assert_false (fp_device_close_finish (FP_DEVICE (device), res, error));
+  g_assert_null (print);
+  g_assert_nonnull (*error);
+}
+
+static void
+test_context_remove_device_closing (void)
+{
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  g_autoptr(GError) close_error = NULL;
+  g_autoptr(GError) error = NULL;
+  gboolean removed;
+
+  tctx->user_data = NULL;
+  g_signal_connect (tctx->device, "removed", (GCallback) device_removed_cb, tctx);
+  g_signal_connect (tctx->fp_context, "device-removed", (GCallback) context_device_removed_cb, tctx);
+
+  fp_device_open_sync (tctx->device, NULL, &error);
+  g_assert_no_error (error);
+
+  /* Triggering remove on device that is being closed. */
+  fp_device_close (tctx->device, NULL, close_done_cb, &close_error);
+  fpi_device_remove (tctx->device);
+
+  /* Removed but not yet notified*/
+  g_assert_nonnull (tctx->device);
+  g_object_get (tctx->device, "removed", &removed, NULL);
+  g_assert_true (removed);
+  g_assert_null (tctx->user_data);
+
+  /* Running the mainloop now will cause the close to fail eventually. */
+  while (!close_error)
+    g_main_context_iteration (NULL, TRUE);
+  g_assert_error (close_error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_REMOVED);
+
+  /* Now the removed callback has been called already. */
+  g_assert_nonnull (tctx->device);
+  g_assert_cmpint (GPOINTER_TO_INT (tctx->user_data), ==, DEV_REMOVED_CB);
+
+  /* While device-removed needs another idle iteration. */
+  while (g_main_context_iteration (NULL, FALSE))
+    {
+    }
+
+  g_assert_null (tctx->device);
+  g_assert_cmpint (GPOINTER_TO_INT (tctx->user_data), ==, CTX_DEVICE_REMOVED_CB);
+
+  fpt_teardown_virtual_device_environment ();
+}
+
+static void
+test_context_remove_device_open (void)
+{
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  g_autoptr(GError) error = NULL;
+  gboolean removed = FALSE;
+
+  tctx->user_data = NULL;
+  g_signal_connect (tctx->fp_context, "device-removed", (GCallback) context_device_removed_cb, tctx);
+  g_signal_connect (tctx->device, "removed", (GCallback) device_removed_cb, tctx);
+
+  fp_device_open_sync (tctx->device, NULL, &error);
+  g_assert_no_error (error);
+
+  /* Triggering remove on open device. */
+  fpi_device_remove (tctx->device);
+
+  g_assert_nonnull (tctx->device);
+  g_object_get (tctx->device, "removed", &removed, NULL);
+  g_assert_true (removed);
+  g_assert_cmpint (GPOINTER_TO_INT (tctx->user_data), ==, DEV_REMOVED_CB);
+
+  /* At this point, the "removed" cb on the device should have been called!
+   * Iterating the mainloop will not change anything.
+   */
+  while (g_main_context_iteration (NULL, FALSE))
+    {
+    }
+  g_assert_cmpint (GPOINTER_TO_INT (tctx->user_data), ==, DEV_REMOVED_CB);
+
+  /* On close, the device will be removed from the context,
+   * but only a main loop iteration later. */
+  fp_device_close_sync (tctx->device, NULL, &error);
+  g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_REMOVED);
+  g_assert_nonnull (tctx->device);
+  g_assert_cmpint (GPOINTER_TO_INT (tctx->user_data), ==, DEV_REMOVED_CB);
+
+  while (g_main_context_iteration (NULL, FALSE))
+    {
+    }
+  g_assert_null (tctx->device);
+  g_assert_cmpint (GPOINTER_TO_INT (tctx->user_data), ==, CTX_DEVICE_REMOVED_CB);
+
+  fpt_teardown_virtual_device_environment ();
+}
+
+static void
+open_done_cb (GObject *device, GAsyncResult *res, gpointer user_data)
+{
+  g_autoptr(GError) error = NULL;
+  g_autoptr(FpPrint) print = NULL;
+  gboolean *data = user_data;
+
+  g_assert_true (fp_device_open_finish (FP_DEVICE (device), res, &error));
+  g_assert_null (print);
+  g_assert_null (error);
+
+  *data = TRUE;
+}
+
+static void
+test_context_remove_device_opening (void)
+{
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  g_autoptr(GError) close_error = NULL;
+  gboolean open_done = FALSE;
+  gboolean removed;
+
+  tctx->user_data = NULL;
+  g_signal_connect (tctx->device, "removed", (GCallback) device_removed_cb, tctx);
+  g_signal_connect (tctx->fp_context, "device-removed", (GCallback) context_device_removed_cb, tctx);
+
+  fp_device_open (tctx->device, NULL, open_done_cb, &open_done);
+  g_assert_false (open_done);
+
+  fpi_device_remove (tctx->device);
+
+  /* Removed but not yet notified*/
+  g_assert_nonnull (tctx->device);
+  g_object_get (tctx->device, "removed", &removed, NULL);
+  g_assert_true (removed);
+  g_assert_null (tctx->user_data);
+
+  /* Running the mainloop now will cause the open to *succeed* dispite removal! */
+  while (!open_done)
+    g_main_context_iteration (NULL, TRUE);
+
+  /* Now the removed callback has been called already. */
+  g_assert_nonnull (tctx->device);
+  g_assert_cmpint (GPOINTER_TO_INT (tctx->user_data), ==, DEV_REMOVED_CB);
+
+  fp_device_close_sync (tctx->device, NULL, &close_error);
+  g_assert_error (close_error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_REMOVED);
+
+  g_assert_nonnull (tctx->device);
+  g_assert_cmpint (GPOINTER_TO_INT (tctx->user_data), ==, DEV_REMOVED_CB);
+
+  /* The device-removed signal needs an idle iteration. */
+  while (g_main_context_iteration (NULL, FALSE))
+    {
+    }
+
+  g_assert_null (tctx->device);
+  g_assert_cmpint (GPOINTER_TO_INT (tctx->user_data), ==, CTX_DEVICE_REMOVED_CB);
+
+  fpt_teardown_virtual_device_environment ();
+}
+
+static void
+enroll_done_cb (GObject *device, GAsyncResult *res, gpointer user_data)
+{
+  g_autoptr(FpPrint) print = NULL;
+  GError **error = user_data;
+
+  g_assert_nonnull (error);
+  print = fp_device_enroll_finish (FP_DEVICE (device), res, error);
+  g_assert_null (print);
+  g_assert_nonnull (*error);
+}
+
+static void
+test_context_remove_device_active (void)
+{
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+  g_autoptr(GError) error = NULL;
+  g_autoptr(GCancellable) cancellable = NULL;
+  g_autoptr(GError) enroll_error = NULL;
+  FpPrint *template;
+  gboolean removed = FALSE;
+
+  tctx->user_data = NULL;
+  g_signal_connect (tctx->fp_context, "device-removed", (GCallback) context_device_removed_cb, tctx);
+  g_signal_connect (tctx->device, "removed", (GCallback) device_removed_cb, tctx);
+
+  fp_device_open_sync (tctx->device, NULL, &error);
+  g_assert_no_error (error);
+
+  /* Start an enroll that we can cancel/fail later.
+   * NOTE: We need to cancel explicitly as remove() does not trigger a failure!
+   */
+  template = fp_print_new (tctx->device);
+  cancellable = g_cancellable_new ();
+  fp_device_enroll (tctx->device, template, cancellable, NULL, NULL, NULL, enroll_done_cb, &enroll_error);
+
+  /* Triggering remove on active device. */
+  fpi_device_remove (tctx->device);
+
+  /* The removed property has changed, but the cb has *not* been called yet. */
+  g_assert_nonnull (tctx->device);
+  g_object_get (tctx->device, "removed", &removed, NULL);
+  g_assert_true (removed);
+  g_assert_null (tctx->user_data);
+
+  /* Running the mainloop now will cause the operation to fail eventually. */
+  while (!enroll_error)
+    g_main_context_iteration (NULL, TRUE);
+
+  /* The virtual image device throws an PROTO error internally,
+   * but we should still receive a REMOVED error here. */
+  g_assert_error (enroll_error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_REMOVED);
+  g_assert_cmpint (GPOINTER_TO_INT (tctx->user_data), ==, DEV_REMOVED_CB);
+
+  /* Now we close the device, state remains unchanged mostly. */
+  fp_device_close_sync (tctx->device, NULL, &error);
+  g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_REMOVED);
+  g_assert_nonnull (tctx->device);
+  g_assert_cmpint (GPOINTER_TO_INT (tctx->user_data), ==, DEV_REMOVED_CB);
+
+  /* And "device-removed" is called */
+  while (g_main_context_iteration (NULL, FALSE))
+    {
+    }
+
+  g_assert_null (tctx->device);
+  g_assert_cmpint (GPOINTER_TO_INT (tctx->user_data), ==, CTX_DEVICE_REMOVED_CB);
+
+  fpt_teardown_virtual_device_environment ();
+}
+
 int
 main (int argc, char *argv[])
 {
@@ -101,6 +392,11 @@ main (int argc, char *argv[])
   g_test_add_func ("/context/no-devices", test_context_has_no_devices);
   g_test_add_func ("/context/has-virtual-device", test_context_has_virtual_device);
   g_test_add_func ("/context/enumerates-new-devices", test_context_enumerates_new_devices);
+  g_test_add_func ("/context/remove-device-closed", test_context_remove_device_closed);
+  g_test_add_func ("/context/remove-device-closing", test_context_remove_device_closing);
+  g_test_add_func ("/context/remove-device-open", test_context_remove_device_open);
+  g_test_add_func ("/context/remove-device-opening", test_context_remove_device_opening);
+  g_test_add_func ("/context/remove-device-active", test_context_remove_device_active);
 
   return g_test_run ();
 }

tests/test-fp-device.c

@@ -178,6 +178,15 @@ test_device_get_scan_type (void)
   g_assert_cmpint (fp_device_get_scan_type (tctx->device), ==, FP_SCAN_TYPE_SWIPE);
 }
 
+static void
+test_device_get_finger_status (void)
+{
+  g_autoptr(FptContext) tctx = fpt_context_new_with_virtual_imgdev ();
+
+  fp_device_open_sync (tctx->device, NULL, NULL);
+  g_assert_cmpint (fp_device_get_finger_status (tctx->device), ==, FP_FINGER_STATUS_NONE);
+}
+
 static void
 test_device_get_nr_enroll_stages (void)
 {
@@ -229,6 +238,7 @@ main (int argc, char *argv[])
   g_test_add_func ("/device/sync/get_device_id", test_device_get_device_id);
   g_test_add_func ("/device/sync/get_name", test_device_get_name);
   g_test_add_func ("/device/sync/get_scan_type", test_device_get_scan_type);
+  g_test_add_func ("/device/sync/get_finger_status", test_device_get_finger_status);
   g_test_add_func ("/device/sync/get_nr_enroll_stages", test_device_get_nr_enroll_stages);
   g_test_add_func ("/device/sync/supports_identify", test_device_supports_identify);
   g_test_add_func ("/device/sync/supports_capture", test_device_supports_capture);

tests/test-fpi-device.c

@@ -200,6 +200,147 @@ test_driver_set_scan_type_swipe (void)
   g_assert_cmpstr (pspec->name, ==, "scan-type");
 }
 
+static void
+test_driver_finger_status_inactive (void)
+{
+  g_autoptr(FpDevice) device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
+  FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
+
+  g_signal_connect (device, "notify::finger-status", G_CALLBACK (on_device_notify), NULL);
+
+  g_assert_false (fpi_device_report_finger_status (device, FP_FINGER_STATUS_NONE));
+  g_assert_cmpuint (fp_device_get_finger_status (device), ==, FP_FINGER_STATUS_NONE);
+  g_assert (fake_dev->last_called_function != on_device_notify);
+  g_assert_null (g_steal_pointer (&fake_dev->user_data));
+}
+
+static void
+test_driver_finger_status_needed (void)
+{
+  g_autoptr(FpDevice) device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
+  g_autoptr(GParamSpec) pspec = NULL;
+  FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
+
+  g_signal_connect (device, "notify::finger-status", G_CALLBACK (on_device_notify), NULL);
+
+  g_assert_true (fpi_device_report_finger_status (device, FP_FINGER_STATUS_NEEDED));
+  g_assert_cmpuint (fp_device_get_finger_status (device), ==, FP_FINGER_STATUS_NEEDED);
+
+  g_assert (fake_dev->last_called_function == on_device_notify);
+  pspec = g_steal_pointer (&fake_dev->user_data);
+  g_assert_cmpstr (pspec->name, ==, "finger-status");
+
+  fake_dev->last_called_function = NULL;
+  g_assert_false (fpi_device_report_finger_status (device, FP_FINGER_STATUS_NEEDED));
+  g_assert_null (fake_dev->last_called_function);
+  g_assert_null (g_steal_pointer (&fake_dev->user_data));
+}
+
+static void
+test_driver_finger_status_present (void)
+{
+  g_autoptr(FpDevice) device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
+  g_autoptr(GParamSpec) pspec = NULL;
+  FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
+
+  g_signal_connect (device, "notify::finger-status", G_CALLBACK (on_device_notify), NULL);
+
+  g_assert_true (fpi_device_report_finger_status (device, FP_FINGER_STATUS_PRESENT));
+  g_assert_cmpuint (fp_device_get_finger_status (device), ==, FP_FINGER_STATUS_PRESENT);
+
+  g_assert (fake_dev->last_called_function == on_device_notify);
+  pspec = g_steal_pointer (&fake_dev->user_data);
+  g_assert_cmpstr (pspec->name, ==, "finger-status");
+
+  fake_dev->last_called_function = NULL;
+  g_assert_false (fpi_device_report_finger_status (device, FP_FINGER_STATUS_PRESENT));
+  g_assert_null (fake_dev->last_called_function);
+  g_assert_null (g_steal_pointer (&fake_dev->user_data));
+}
+
+static void
+driver_finger_status_changes_check (FpDevice *device, gboolean add)
+{
+  FpiDeviceFake *fake_dev = FPI_DEVICE_FAKE (device);
+
+  g_autoptr(GFlagsClass) status_class = g_type_class_ref (FP_TYPE_FINGER_STATUS_FLAGS);
+  guint expected_status;
+  guint initial_value;
+  guint i;
+  gulong signal_id;
+
+  if (add)
+    initial_value = FP_FINGER_STATUS_NONE;
+  else
+    initial_value = status_class->mask;
+
+  g_assert_cmpuint (fp_device_get_finger_status (device), ==, initial_value);
+
+  signal_id = g_signal_connect (device, "notify::finger-status",
+                                G_CALLBACK (on_device_notify), NULL);
+
+  for (i = 0, expected_status = initial_value; i < status_class->n_values; ++i)
+    {
+      g_autoptr(GParamSpec) pspec = NULL;
+      FpFingerStatusFlags finger_status = status_class->values[i].value;
+      FpFingerStatusFlags added_status = add ? finger_status : FP_FINGER_STATUS_NONE;
+      FpFingerStatusFlags removed_status = add ? FP_FINGER_STATUS_NONE : finger_status;
+      gboolean ret;
+
+      fake_dev->last_called_function = NULL;
+      ret = fpi_device_report_finger_status_changes (device,
+                                                     added_status,
+                                                     removed_status);
+      if (finger_status != FP_FINGER_STATUS_NONE)
+        g_assert_true (ret);
+      else
+        g_assert_false (ret);
+
+      expected_status |= added_status;
+      expected_status &= ~removed_status;
+
+      g_assert_cmpuint (fp_device_get_finger_status (device), ==, expected_status);
+
+      if (finger_status != FP_FINGER_STATUS_NONE)
+        {
+          g_assert (fake_dev->last_called_function == on_device_notify);
+          pspec = g_steal_pointer (&fake_dev->user_data);
+          g_assert_cmpstr (pspec->name, ==, "finger-status");
+        }
+
+      fake_dev->last_called_function = NULL;
+      g_assert_false (fpi_device_report_finger_status_changes (device,
+                                                               added_status,
+                                                               removed_status));
+      g_assert_null (fake_dev->last_called_function);
+      g_assert_null (g_steal_pointer (&fake_dev->user_data));
+    }
+
+  if (add)
+    g_assert_cmpuint (fp_device_get_finger_status (device), ==, status_class->mask);
+  else
+    g_assert_cmpuint (fp_device_get_finger_status (device), ==, FP_FINGER_STATUS_NONE);
+
+  fake_dev->last_called_function = NULL;
+  g_assert_false (fpi_device_report_finger_status_changes (device,
+                                                           FP_FINGER_STATUS_NONE,
+                                                           FP_FINGER_STATUS_NONE));
+
+  g_assert_null (fake_dev->last_called_function);
+  g_assert_null (g_steal_pointer (&fake_dev->user_data));
+
+  g_signal_handler_disconnect (device, signal_id);
+}
+
+static void
+test_driver_finger_status_changes (void)
+{
+  g_autoptr(FpDevice) device = g_object_new (FPI_TYPE_DEVICE_FAKE, NULL);
+
+  driver_finger_status_changes_check (device, TRUE);
+  driver_finger_status_changes_check (device, FALSE);
+}
+
 static void
 test_driver_get_nr_enroll_stages (void)
 {
@@ -447,7 +588,7 @@ test_driver_close_error (void)
   g_assert (fake_dev->last_called_function == dev_class->close);
   g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_GENERAL);
   g_assert (error == g_steal_pointer (&fake_dev->ret_error));
-  g_assert_true (fp_device_is_open (device));
+  g_assert_false (fp_device_is_open (device));
 }
 
 static void
@@ -1928,12 +2069,6 @@ test_driver_action_error_all (void)
 
   fake_dev->return_action_error = TRUE;
 
-  fake_dev->ret_error = fpi_device_error_new (FP_DEVICE_ERROR_DATA_INVALID);
-  g_assert_false (fp_device_close_sync (device, NULL, &error));
-  g_assert_true (fake_dev->last_called_function == dev_class->close);
-  g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_DATA_INVALID);
-  g_clear_error (&error);
-
   fake_dev->ret_error = fpi_device_error_new (FP_DEVICE_ERROR_DATA_INVALID);
   g_assert_null (fp_device_enroll_sync (device, fp_print_new (device), NULL,
                                         NULL, NULL, &error));
@@ -1972,6 +2107,13 @@ test_driver_action_error_all (void)
   g_assert_true (fake_dev->last_called_function == dev_class->delete);
   g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_DATA_INVALID);
   g_clear_error (&error);
+
+  /* Test close last, as we can't operate on a closed device. */
+  fake_dev->ret_error = fpi_device_error_new (FP_DEVICE_ERROR_DATA_INVALID);
+  g_assert_false (fp_device_close_sync (device, NULL, &error));
+  g_assert_true (fake_dev->last_called_function == dev_class->close);
+  g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_DATA_INVALID);
+  g_clear_error (&error);
 }
 
 static void
@@ -2005,16 +2147,6 @@ test_driver_action_error_fallback_all (void)
                          "error function*");
 
   fake_dev->return_action_error = TRUE;
-  g_assert_false (fp_device_close_sync (device, NULL, &error));
-  g_test_assert_expected_messages ();
-  g_assert_true (fake_dev->last_called_function == dev_class->close);
-  g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_GENERAL);
-  g_clear_error (&error);
-
-  g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
-                         "*Device failed to pass an error to generic action "
-                         "error function*");
-
   g_assert_null (fp_device_enroll_sync (device, fp_print_new (device), NULL,
                                         NULL, NULL, &error));
   g_test_assert_expected_messages ();
@@ -2074,6 +2206,17 @@ test_driver_action_error_fallback_all (void)
   g_assert_true (fake_dev->last_called_function == dev_class->delete);
   g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_GENERAL);
   g_clear_error (&error);
+
+  /* Test close last, as we can't operate on a closed device. */
+  g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
+                         "*Device failed to pass an error to generic action "
+                         "error function*");
+
+  g_assert_false (fp_device_close_sync (device, NULL, &error));
+  g_test_assert_expected_messages ();
+  g_assert_true (fake_dev->last_called_function == dev_class->close);
+  g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_GENERAL);
+  g_clear_error (&error);
 }
 
 static void
@@ -2207,6 +2350,10 @@ main (int argc, char *argv[])
   g_test_add_func ("/driver/get_scan_type/swipe", test_driver_get_scan_type_swipe);
   g_test_add_func ("/driver/set_scan_type/press", test_driver_set_scan_type_press);
   g_test_add_func ("/driver/set_scan_type/swipe", test_driver_set_scan_type_swipe);
+  g_test_add_func ("/driver/finger_status/inactive", test_driver_finger_status_inactive);
+  g_test_add_func ("/driver/finger_status/waiting", test_driver_finger_status_needed);
+  g_test_add_func ("/driver/finger_status/present", test_driver_finger_status_present);
+  g_test_add_func ("/driver/finger_status/changes", test_driver_finger_status_changes);
   g_test_add_func ("/driver/get_nr_enroll_stages", test_driver_get_nr_enroll_stages);
   g_test_add_func ("/driver/set_nr_enroll_stages", test_driver_set_nr_enroll_stages);
   g_test_add_func ("/driver/supports_identify", test_driver_supports_identify);

tests/umockdev-test.py

@@ -87,6 +87,11 @@ try:
     if os.path.exists(os.path.join(ddir, "custom.ioctl")):
         custom()
 
+except:
+    # Store created output files for inspection (in the build directory)
+    outdir = os.path.join('errors', os.path.basename(ddir))
+    shutil.copytree(tmpdir, outdir)
+
 finally:
     shutil.rmtree(tmpdir)
 

tests/vfs301/device

@@ -0,0 +1,307 @@
+P: /devices/pci0000:00/0000:00:1d.0/usb2/2-1/2-1.3
+N: bus/usb/002/005=12011001FF10FF088A130500900C0000000109022700010100A0320904000003FF000000070501024000000705810240000007058202400000
+E: DEVNAME=/dev/bus/usb/002/005
+E: DEVTYPE=usb_device
+E: DRIVER=usb
+E: PRODUCT=138a/5/c90
+E: TYPE=255/16/255
+E: BUSNUM=002
+E: DEVNUM=005
+E: MAJOR=189
+E: MINOR=132
+E: SUBSYSTEM=usb
+E: ID_VENDOR=138a
+E: ID_VENDOR_ENC=138a
+E: ID_VENDOR_ID=138a
+E: ID_MODEL=0005
+E: ID_MODEL_ENC=0005
+E: ID_MODEL_ID=0005
+E: ID_REVISION=0c90
+E: ID_SERIAL=138a_0005
+E: ID_BUS=usb
+E: ID_USB_INTERFACES=:ff0000:
+E: ID_VENDOR_FROM_DATABASE=Validity Sensors, Inc.
+E: ID_MODEL_FROM_DATABASE=VFS301 Fingerprint Reader
+E: ID_PATH=pci-0000:00:1d.0-usb-0:1.3
+E: ID_PATH_TAG=pci-0000_00_1d_0-usb-0_1_3
+E: LIBFPRINT_DRIVER=Validity VFS301
+A: authorized=1
+A: avoid_reset_quirk=0
+A: bConfigurationValue=1
+A: bDeviceClass=ff
+A: bDeviceProtocol=ff
+A: bDeviceSubClass=10
+A: bMaxPacketSize0=8
+A: bMaxPower=100mA
+A: bNumConfigurations=1
+A: bNumInterfaces= 1
+A: bcdDevice=0c90
+A: bmAttributes=a0
+A: busnum=2
+A: configuration=
+H: descriptors=12011001FF10FF088A130500900C0000000109022700010100A0320904000003FF000000070501024000000705810240000007058202400000
+A: dev=189:132
+A: devnum=5
+A: devpath=1.3
+L: driver=../../../../../../bus/usb/drivers/usb
+A: idProduct=0005
+A: idVendor=138a
+A: ltm_capable=no
+A: maxchild=0
+L: port=../2-1:1.0/2-1-port3
+A: power/active_duration=1612976
+A: power/async=enabled
+A: power/autosuspend=2
+A: power/autosuspend_delay_ms=2000
+A: power/connected_duration=2159928
+A: power/control=auto
+A: power/level=auto
+A: power/persist=1
+A: power/runtime_active_kids=0
+A: power/runtime_active_time=1612851
+A: power/runtime_enabled=enabled
+A: power/runtime_status=active
+A: power/runtime_suspended_time=546887
+A: power/runtime_usage=0
+A: power/wakeup=disabled
+A: power/wakeup_abort_count=
+A: power/wakeup_active=
+A: power/wakeup_active_count=
+A: power/wakeup_count=
+A: power/wakeup_expire_count=
+A: power/wakeup_last_time_ms=
+A: power/wakeup_max_time_ms=
+A: power/wakeup_total_time_ms=
+A: quirks=0x0
+A: removable=fixed
+A: rx_lanes=1
+A: speed=12
+A: tx_lanes=1
+A: urbnum=7
+A: version= 1.10
+
+P: /devices/pci0000:00/0000:00:1d.0/usb2/2-1
+N: bus/usb/002/002=12010002090001408780200000000000000109021900010100E0000904000001090000000705810302000C
+E: DEVNAME=/dev/bus/usb/002/002
+E: DEVTYPE=usb_device
+E: DRIVER=usb
+E: PRODUCT=8087/20/0
+E: TYPE=9/0/1
+E: BUSNUM=002
+E: DEVNUM=002
+E: MAJOR=189
+E: MINOR=129
+E: SUBSYSTEM=usb
+E: ID_VENDOR=8087
+E: ID_VENDOR_ENC=8087
+E: ID_VENDOR_ID=8087
+E: ID_MODEL=0020
+E: ID_MODEL_ENC=0020
+E: ID_MODEL_ID=0020
+E: ID_REVISION=0000
+E: ID_SERIAL=8087_0020
+E: ID_BUS=usb
+E: ID_USB_INTERFACES=:090000:
+E: ID_VENDOR_FROM_DATABASE=Intel Corp.
+E: ID_MODEL_FROM_DATABASE=Integrated Rate Matching Hub
+E: ID_PATH=pci-0000:00:1d.0-usb-0:1
+E: ID_PATH_TAG=pci-0000_00_1d_0-usb-0_1
+E: ID_FOR_SEAT=usb-pci-0000_00_1d_0-usb-0_1
+E: TAGS=:seat:
+A: authorized=1
+A: avoid_reset_quirk=0
+A: bConfigurationValue=1
+A: bDeviceClass=09
+A: bDeviceProtocol=01
+A: bDeviceSubClass=00
+A: bMaxPacketSize0=64
+A: bMaxPower=0mA
+A: bNumConfigurations=1
+A: bNumInterfaces= 1
+A: bcdDevice=0000
+A: bmAttributes=e0
+A: busnum=2
+A: configuration=
+H: descriptors=12010002090001408780200000000000000109021900010100E0000904000001090000000705810302000C
+A: dev=189:129
+A: devnum=2
+A: devpath=1
+L: driver=../../../../../bus/usb/drivers/usb
+A: idProduct=0020
+A: idVendor=8087
+A: ltm_capable=no
+A: maxchild=8
+L: port=../2-0:1.0/usb2-port1
+A: power/active_duration=2160820
+A: power/async=enabled
+A: power/autosuspend=0
+A: power/autosuspend_delay_ms=0
+A: power/connected_duration=2160824
+A: power/control=auto
+A: power/level=auto
+A: power/runtime_active_kids=3
+A: power/runtime_active_time=2160531
+A: power/runtime_enabled=enabled
+A: power/runtime_status=active
+A: power/runtime_suspended_time=0
+A: power/runtime_usage=0
+A: power/wakeup=disabled
+A: power/wakeup_abort_count=
+A: power/wakeup_active=
+A: power/wakeup_active_count=
+A: power/wakeup_count=
+A: power/wakeup_expire_count=
+A: power/wakeup_last_time_ms=
+A: power/wakeup_max_time_ms=
+A: power/wakeup_total_time_ms=
+A: quirks=0x0
+A: removable=fixed
+A: rx_lanes=1
+A: speed=480
+A: tx_lanes=1
+A: urbnum=75
+A: version= 2.00
+
+P: /devices/pci0000:00/0000:00:1d.0/usb2
+N: bus/usb/002/001=12010002090000406B1D020004050302010109021900010100E0000904000001090000000705810304000C
+E: DEVNAME=/dev/bus/usb/002/001
+E: DEVTYPE=usb_device
+E: DRIVER=usb
+E: PRODUCT=1d6b/2/504
+E: TYPE=9/0/0
+E: BUSNUM=002
+E: DEVNUM=001
+E: MAJOR=189
+E: MINOR=128
+E: SUBSYSTEM=usb
+E: ID_VENDOR=Linux_5.4.0-48-generic_ehci_hcd
+E: ID_VENDOR_ENC=Linux\x205.4.0-48-generic\x20ehci_hcd
+E: ID_VENDOR_ID=1d6b
+E: ID_MODEL=EHCI_Host_Controller
+E: ID_MODEL_ENC=EHCI\x20Host\x20Controller
+E: ID_MODEL_ID=0002
+E: ID_REVISION=0504
+E: ID_SERIAL=Linux_5.4.0-48-generic_ehci_hcd_EHCI_Host_Controller_0000:00:1d.0
+E: ID_SERIAL_SHORT=0000:00:1d.0
+E: ID_BUS=usb
+E: ID_USB_INTERFACES=:090000:
+E: ID_VENDOR_FROM_DATABASE=Linux Foundation
+E: ID_MODEL_FROM_DATABASE=2.0 root hub
+E: ID_PATH=pci-0000:00:1d.0
+E: ID_PATH_TAG=pci-0000_00_1d_0
+E: ID_FOR_SEAT=usb-pci-0000_00_1d_0
+E: TAGS=:seat:
+A: authorized=1
+A: authorized_default=1
+A: avoid_reset_quirk=0
+A: bConfigurationValue=1
+A: bDeviceClass=09
+A: bDeviceProtocol=00
+A: bDeviceSubClass=00
+A: bMaxPacketSize0=64
+A: bMaxPower=0mA
+A: bNumConfigurations=1
+A: bNumInterfaces= 1
+A: bcdDevice=0504
+A: bmAttributes=e0
+A: busnum=2
+A: configuration=
+H: descriptors=12010002090000406B1D020004050302010109021900010100E0000904000001090000000705810304000C
+A: dev=189:128
+A: devnum=1
+A: devpath=0
+L: driver=../../../../bus/usb/drivers/usb
+A: idProduct=0002
+A: idVendor=1d6b
+A: interface_authorized_default=1
+A: ltm_capable=no
+A: manufacturer=Linux 5.4.0-48-generic ehci_hcd
+A: maxchild=3
+A: power/active_duration=2161060
+A: power/async=enabled
+A: power/autosuspend=0
+A: power/autosuspend_delay_ms=0
+A: power/connected_duration=2161060
+A: power/control=auto
+A: power/level=auto
+A: power/runtime_active_kids=1
+A: power/runtime_active_time=2161035
+A: power/runtime_enabled=enabled
+A: power/runtime_status=active
+A: power/runtime_suspended_time=0
+A: power/runtime_usage=0
+A: power/wakeup=disabled
+A: power/wakeup_abort_count=
+A: power/wakeup_active=
+A: power/wakeup_active_count=
+A: power/wakeup_count=
+A: power/wakeup_expire_count=
+A: power/wakeup_last_time_ms=
+A: power/wakeup_max_time_ms=
+A: power/wakeup_total_time_ms=
+A: product=EHCI Host Controller
+A: quirks=0x0
+A: removable=unknown
+A: rx_lanes=1
+A: serial=0000:00:1d.0
+A: speed=480
+A: tx_lanes=1
+A: urbnum=26
+A: version= 2.00
+
+P: /devices/pci0000:00/0000:00:1d.0
+E: DRIVER=ehci-pci
+E: PCI_CLASS=C0320
+E: PCI_ID=8086:3B34
+E: PCI_SUBSYS_ID=103C:7001
+E: PCI_SLOT_NAME=0000:00:1d.0
+E: MODALIAS=pci:v00008086d00003B34sv0000103Csd00007001bc0Csc03i20
+E: SUBSYSTEM=pci
+E: ID_PCI_CLASS_FROM_DATABASE=Serial bus controller
+E: ID_PCI_SUBCLASS_FROM_DATABASE=USB controller
+E: ID_PCI_INTERFACE_FROM_DATABASE=EHCI
+E: ID_VENDOR_FROM_DATABASE=Intel Corporation
+E: ID_MODEL_FROM_DATABASE=5 Series/3400 Series Chipset USB2 Enhanced Host Controller
+A: ari_enabled=0
+A: broken_parity_status=0
+A: class=0x0c0320
+A: companion=
+H: config=8680343B060090020520030C00000000005810DB0000000000000000000000000000000000000000000000003C1001700000000050000000000000000B010000
+A: consistent_dma_mask_bits=32
+A: d3cold_allowed=1
+A: device=0x3b34
+A: dma_mask_bits=32
+L: driver=../../../bus/pci/drivers/ehci-pci
+A: driver_override=(null)
+A: enable=1
+A: irq=21
+A: local_cpulist=0-7
+A: local_cpus=ff
+A: modalias=pci:v00008086d00003B34sv0000103Csd00007001bc0Csc03i20
+A: msi_bus=1
+A: numa_node=-1
+A: pools=poolinfo - 0.1\nehci_sitd           0    0   96  0\nehci_itd            0    0  192  0\nehci_qh            12   42   96  1\nehci_qtd           13   84   96  2\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          2   32  128  1\nbuffer-32           0    0   32  0
+A: power/async=enabled
+A: power/control=on
+A: power/runtime_active_kids=1
+A: power/runtime_active_time=2161633
+A: power/runtime_enabled=forbidden
+A: power/runtime_status=active
+A: power/runtime_suspended_time=0
+A: power/runtime_usage=1
+A: power/wakeup=enabled
+A: power/wakeup_abort_count=0
+A: power/wakeup_active=0
+A: power/wakeup_active_count=0
+A: power/wakeup_count=0
+A: power/wakeup_expire_count=0
+A: power/wakeup_last_time_ms=0
+A: power/wakeup_max_time_ms=0
+A: power/wakeup_total_time_ms=0
+A: resource=0x00000000db105800 0x00000000db105bff 0x0000000000040200\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000
+A: revision=0x05
+A: subsystem_device=0x7001
+A: subsystem_vendor=0x103c
+A: uframe_periodic_max=100
+A: vendor=0x8086
+

tests/virtual-image.py

@@ -172,6 +172,7 @@ class VirtualImage(unittest.TestCase):
         def done_cb(dev, res):
             print("Enroll done")
             fp = dev.enroll_finish(res)
+            self.assertEqual(self.dev.get_finger_status(), FPrint.FingerStatusFlags.NONE)
             self._enrolled = fp
 
         template = FPrint.Print.new(self.dev)
@@ -182,6 +183,7 @@ class VirtualImage(unittest.TestCase):
         date = GLib.Date()
         date.set_dmy(*datetime.get_ymd()[::-1])
         template.props.enroll_date = date
+        self.assertEqual(self.dev.get_finger_status(), FPrint.FingerStatusFlags.NONE)
         self.dev.enroll(template, None, progress_cb, tuple(), done_cb)
 
         # Note: Assumes 5 enroll steps for this device!
@@ -192,25 +194,36 @@ class VirtualImage(unittest.TestCase):
         # Test the image-device path where the finger is removed after
         # the minutiae scan is completed.
         self.send_finger_automatic(False)
+        self.assertEqual(self.dev.get_finger_status(), FPrint.FingerStatusFlags.NEEDED)
         self.send_finger_report(True)
+        self.assertEqual(self.dev.get_finger_status(),
+            FPrint.FingerStatusFlags.NEEDED | FPrint.FingerStatusFlags.PRESENT)
         self.send_image(image)
         while self._step < 2:
             ctx.iteration(True)
         self.send_finger_report(False)
 
+        self.assertEqual(self.dev.get_finger_status(), FPrint.FingerStatusFlags.NEEDED)
+
         self.send_finger_automatic(True)
         self.send_image(image)
         while self._step < 3:
             ctx.iteration(True)
 
+        self.assertEqual(self.dev.get_finger_status(), FPrint.FingerStatusFlags.NEEDED)
+
         self.send_image(image)
         while self._step < 4:
             ctx.iteration(True)
 
+        self.assertEqual(self.dev.get_finger_status(), FPrint.FingerStatusFlags.NEEDED)
+
         self.send_image(image)
         while self._enrolled is None:
             ctx.iteration(True)
 
+        self.assertEqual(self.dev.get_finger_status(), FPrint.FingerStatusFlags.NONE)
+
         return self._enrolled
 
     def test_enroll_verify(self):