From c5e49592cdba6fa91a2d560b7435a661baace94a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marco=20Trevisan=20=28Trevi=C3=B1o=29?= Date: Fri, 10 Jul 2026 04:31:49 +0200 Subject: [PATCH] drivers: Remove redundant verify implementations As per recent changes, drivers can just avoid implementing verify vfunc unless the driver has specific commands to do it. So let's just drop the duplicated code in drivers that have the very same code path for both identification and verification. --- libfprint/drivers/egismoc/egis_etu905.c | 53 +-- libfprint/drivers/egismoc/egismoc.c | 53 +-- libfprint/drivers/elanmoc/elanmoc.c | 66 +--- .../drivers/focaltech_moc/focaltech_moc.c | 64 +--- libfprint/drivers/fpcmoc/fpc.c | 106 ++---- libfprint/drivers/fpcmoc/fpc.h | 10 +- libfprint/drivers/goodixmoc/goodix.c | 106 +++--- libfprint/drivers/goodixmoc/goodix.h | 12 +- libfprint/drivers/mafpmoc/mafpmoc.c | 310 ++++++++---------- libfprint/drivers/mafpmoc/mafpmoc.h | 32 +- 10 files changed, 299 insertions(+), 513 deletions(-) diff --git a/libfprint/drivers/egismoc/egis_etu905.c b/libfprint/drivers/egismoc/egis_etu905.c index 7529107a..84c6dd4b 100644 --- a/libfprint/drivers/egismoc/egis_etu905.c +++ b/libfprint/drivers/egismoc/egis_etu905.c @@ -951,7 +951,7 @@ egis_etu905_enroll_begin_cb (FpDevice *device, /* * Builds the full "check" payload which includes identifiers for all * fingerprints which currently should exist on the storage. This payload is - * used during both enrollment and verify actions. + * used during both enrollment and identify actions. */ static guchar * egis_etu905_get_check_cmd (FpDevice *device, @@ -1184,7 +1184,6 @@ egis_etu905_identify_check_cb (FpDevice *device, FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device); guint8 device_print_id[EGIS_ETU905_FINGERPRINT_DATA_SIZE]; FpPrint *print = NULL; - FpPrint *verify_print = NULL; GPtrArray *prints; gboolean found = FALSE; guint index; @@ -1260,29 +1259,16 @@ egis_etu905_identify_check_cb (FpDevice *device, fp_info ("Identify successful for: %s", fp_print_get_description (print)); - if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_IDENTIFY) - { - fpi_device_get_identify_data (device, &prints); - found = g_ptr_array_find_with_equal_func (prints, - print, - (GEqualFunc) fp_print_equal, - &index); + fpi_device_get_identify_data (device, &prints); + found = g_ptr_array_find_with_equal_func (prints, + print, + (GEqualFunc) fp_print_equal, + &index); - if (found) - fpi_device_identify_report (device, g_ptr_array_index (prints, index), print, NULL); - else - fpi_device_identify_report (device, NULL, print, NULL); - } + if (found) + fpi_device_identify_report (device, g_ptr_array_index (prints, index), print, NULL); else - { - fpi_device_get_verify_data (device, &verify_print); - fp_info ("Verifying against: %s", fp_print_get_description (verify_print)); - - if (fp_print_equal (verify_print, print)) - fpi_device_verify_report (device, FPI_MATCH_SUCCESS, print, NULL); - else - fpi_device_verify_report (device, FPI_MATCH_FAIL, print, NULL); - } + fpi_device_identify_report (device, NULL, print, NULL); } /* If device was successfully read but it was a "not matched" */ else if (egis_etu905_validate_response_suffix (buffer_in, @@ -1292,10 +1278,7 @@ egis_etu905_identify_check_cb (FpDevice *device, { fp_info ("Print was not identified by the device"); - if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY) - fpi_device_verify_report (device, FPI_MATCH_FAIL, NULL, NULL); - else - fpi_device_identify_report (device, NULL, NULL, NULL); + fpi_device_identify_report (device, NULL, NULL, NULL); } else { @@ -1367,17 +1350,14 @@ egis_etu905_identify_run_state (FpiSsm *ssm, /* * In Windows, the driver seems at this point to then immediately take * another read from the sensor; this is suspected to be an on-chip - * "verify". However, because the user's finger is still on the sensor from + * "identify". However, because the user's finger is still on the sensor from * the identify, then it seems to always return positive. We will consider * this extra step unnecessary and just skip it in this driver. This driver * will instead handle matching of the FpPrint from the gallery in the - * "verify" case of the callback egis_etu905_identify_check_cb. + * callback egis_etu905_identify_check_cb. */ case IDENTIFY_COMPLETE: - if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_IDENTIFY) - fpi_device_identify_complete (device, NULL); - else - fpi_device_verify_complete (device, NULL); + fpi_device_identify_complete (device, NULL); fpi_ssm_mark_completed (ssm); break; @@ -1385,9 +1365,9 @@ egis_etu905_identify_run_state (FpiSsm *ssm, } static void -egis_etu905_identify_verify (FpDevice *device) +egis_etu905_identify (FpDevice *device) { - fp_dbg ("Identify or Verify"); + fp_dbg ("Identify"); FpiDeviceEgisEtu905 *self = FPI_DEVICE_EGIS_ETU905 (device); g_assert (self->task_ssm == NULL); @@ -1656,8 +1636,7 @@ fpi_device_egis_etu905_class_init (FpiDeviceEgisEtu905Class *klass) dev_class->probe = egis_etu905_probe; dev_class->open = egis_etu905_open; dev_class->close = egis_etu905_close; - dev_class->identify = egis_etu905_identify_verify; - dev_class->verify = egis_etu905_identify_verify; + dev_class->identify = egis_etu905_identify; dev_class->enroll = egis_etu905_enroll; dev_class->delete = egis_etu905_delete; dev_class->clear_storage = egis_etu905_clear_storage; diff --git a/libfprint/drivers/egismoc/egismoc.c b/libfprint/drivers/egismoc/egismoc.c index 89786dce..4ee15044 100644 --- a/libfprint/drivers/egismoc/egismoc.c +++ b/libfprint/drivers/egismoc/egismoc.c @@ -889,7 +889,7 @@ egismoc_enroll_check_cb (FpDevice *device, /* * Builds the full "check" payload which includes identifiers for all * fingerprints which currently should exist on the storage. This payload is - * used during both enrollment and verify actions. + * used during both enrollment and identify actions. */ static guchar * egismoc_get_check_cmd (FpDevice *device, @@ -1157,7 +1157,6 @@ egismoc_identify_check_cb (FpDevice *device, FpiDeviceEgisMoc *self = FPI_DEVICE_EGISMOC (device); gchar device_print_id[EGISMOC_FINGERPRINT_DATA_SIZE]; FpPrint *print = NULL; - FpPrint *verify_print = NULL; GPtrArray *prints; gboolean found = FALSE; guint index; @@ -1199,29 +1198,16 @@ egismoc_identify_check_cb (FpDevice *device, fp_info ("Identify successful for: %s", fp_print_get_description (print)); - if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_IDENTIFY) - { - fpi_device_get_identify_data (device, &prints); - found = g_ptr_array_find_with_equal_func (prints, - print, - (GEqualFunc) fp_print_equal, - &index); + fpi_device_get_identify_data (device, &prints); + found = g_ptr_array_find_with_equal_func (prints, + print, + (GEqualFunc) fp_print_equal, + &index); - if (found) - fpi_device_identify_report (device, g_ptr_array_index (prints, index), print, NULL); - else - fpi_device_identify_report (device, NULL, print, NULL); - } + if (found) + fpi_device_identify_report (device, g_ptr_array_index (prints, index), print, NULL); else - { - fpi_device_get_verify_data (device, &verify_print); - fp_info ("Verifying against: %s", fp_print_get_description (verify_print)); - - if (fp_print_equal (verify_print, print)) - fpi_device_verify_report (device, FPI_MATCH_SUCCESS, print, NULL); - else - fpi_device_verify_report (device, FPI_MATCH_FAIL, print, NULL); - } + fpi_device_identify_report (device, NULL, print, NULL); } /* If device was successfully read but it was a "not matched" */ else if (egismoc_validate_response_suffix (buffer_in, @@ -1231,10 +1217,7 @@ egismoc_identify_check_cb (FpDevice *device, { fp_info ("Print was not identified by the device"); - if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY) - fpi_device_verify_report (device, FPI_MATCH_FAIL, NULL, NULL); - else - fpi_device_identify_report (device, NULL, NULL, NULL); + fpi_device_identify_report (device, NULL, NULL, NULL); } else { @@ -1306,17 +1289,14 @@ egismoc_identify_run_state (FpiSsm *ssm, /* * In Windows, the driver seems at this point to then immediately take * another read from the sensor; this is suspected to be an on-chip - * "verify". However, because the user's finger is still on the sensor from + * "identify". However, because the user's finger is still on the sensor from * the identify, then it seems to always return positive. We will consider * this extra step unnecessary and just skip it in this driver. This driver * will instead handle matching of the FpPrint from the gallery in the - * "verify" case of the callback egismoc_identify_check_cb. + * callback egismoc_identify_check_cb. */ case IDENTIFY_COMPLETE: - if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_IDENTIFY) - fpi_device_identify_complete (device, NULL); - else - fpi_device_verify_complete (device, NULL); + fpi_device_identify_complete (device, NULL); fpi_ssm_mark_completed (ssm); break; @@ -1324,9 +1304,9 @@ egismoc_identify_run_state (FpiSsm *ssm, } static void -egismoc_identify_verify (FpDevice *device) +egismoc_identify (FpDevice *device) { - fp_dbg ("Identify or Verify"); + fp_dbg ("Identify"); FpiDeviceEgisMoc *self = FPI_DEVICE_EGISMOC (device); g_assert (self->task_ssm == NULL); @@ -1619,8 +1599,7 @@ fpi_device_egismoc_class_init (FpiDeviceEgisMocClass *klass) dev_class->cancel = egismoc_cancel; dev_class->suspend = egismoc_suspend; dev_class->close = egismoc_close; - dev_class->identify = egismoc_identify_verify; - dev_class->verify = egismoc_identify_verify; + dev_class->identify = egismoc_identify; dev_class->enroll = egismoc_enroll; dev_class->delete = egismoc_delete; dev_class->clear_storage = egismoc_clear_storage; diff --git a/libfprint/drivers/elanmoc/elanmoc.c b/libfprint/drivers/elanmoc/elanmoc.c index 74879ba9..3d8141a0 100644 --- a/libfprint/drivers/elanmoc/elanmoc.c +++ b/libfprint/drivers/elanmoc/elanmoc.c @@ -639,7 +639,6 @@ elanmoc_match_report_cb (FpiDeviceElanmoc *self, { FpDevice *device = FP_DEVICE (self); FpPrint *print = NULL; - FpPrint *verify_print = NULL; GPtrArray *prints; gboolean found = FALSE; guint index; @@ -668,31 +667,18 @@ elanmoc_match_report_cb (FpiDeviceElanmoc *self, fp_info ("Verify/Identify successful for: %s", fp_print_get_description (print)); - if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_IDENTIFY) - { - fpi_device_get_identify_data (device, &prints); - found = g_ptr_array_find_with_equal_func (prints, - print, - (GEqualFunc) fp_print_equal, - &index); + fpi_device_get_identify_data (device, &prints); + found = g_ptr_array_find_with_equal_func (prints, + print, + (GEqualFunc) fp_print_equal, + &index); - if (found) - fpi_device_identify_report (device, g_ptr_array_index (prints, index), print, NULL); - else - fpi_device_identify_report (device, NULL, print, NULL); - - fpi_device_identify_complete (device, NULL); - } + if (found) + fpi_device_identify_report (device, g_ptr_array_index (prints, index), print, NULL); else - { - fpi_device_get_verify_data (device, &verify_print); + fpi_device_identify_report (device, NULL, print, NULL); - if (fp_print_equal (verify_print, print)) - fpi_device_verify_report (device, FPI_MATCH_SUCCESS, print, NULL); - else - fpi_device_verify_report (device, FPI_MATCH_FAIL, print, NULL); - fpi_device_verify_complete (device, NULL); - } + fpi_device_identify_complete (device, NULL); } static void @@ -704,10 +690,7 @@ identify_status_report (FpiDeviceElanmoc *self, int verify_status_id, if (error) { - if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY) - fpi_device_verify_complete (device, error); - else - fpi_device_identify_complete (device, error); + fpi_device_identify_complete (device, error); return; } @@ -717,16 +700,8 @@ identify_status_report (FpiDeviceElanmoc *self, int verify_status_id, { if (data == ELAN_MSG_VERIFY_ERR) { - if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY) - { - fpi_device_verify_report (device, FPI_MATCH_FAIL, NULL, NULL); - fpi_device_verify_complete (device, NULL); - } - else - { - fpi_device_identify_report (device, NULL, NULL, NULL); - fpi_device_identify_complete (device, NULL); - } + fpi_device_identify_report (device, NULL, NULL, NULL); + fpi_device_identify_complete (device, NULL); } else { @@ -745,23 +720,15 @@ identify_status_report (FpiDeviceElanmoc *self, int verify_status_id, retry_error = fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL); } - if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY) - { - fpi_device_verify_report (device, FPI_MATCH_ERROR, NULL, retry_error); - fpi_device_verify_complete (device, NULL); - } - else - { - fpi_device_identify_report (device, NULL, NULL, retry_error); - fpi_device_identify_complete (device, NULL); - } + fpi_device_identify_report (device, NULL, NULL, retry_error); + fpi_device_identify_complete (device, NULL); } break; } case RSP_VERIFY_OK: { - fp_dbg ("Verify was successful! for user: %d mesg_code: %d ", data, verify_status_id); + fp_dbg ("Identify was successful! for user: %d mesg_code: %d ", data, verify_status_id); cmd_buf = elanmoc_compose_cmd (&elanmoc_get_userid_cmd); cmd_buf[2] = data; elanmoc_get_cmd (device, cmd_buf, elanmoc_get_userid_cmd.cmd_len, elanmoc_get_userid_cmd.resp_len, 0, elanmoc_match_report_cb); @@ -815,7 +782,7 @@ elan_identify_run_state (FpiSsm *ssm, FpDevice *dev) break; case IDENTIFY_WAIT_FINGER: - fp_info ("elanmoc %s VERIFY_WAIT_FINGER", __func__); + fp_info ("elanmoc %s IDENTIFY_WAIT_FINGER", __func__); cmd_buf = elanmoc_compose_cmd (&elanmoc_verify_cmd); elanmoc_get_cmd (dev, cmd_buf, elanmoc_verify_cmd.cmd_len, elanmoc_verify_cmd.resp_len, 1, elanmoc_identify_cb); break; @@ -1175,7 +1142,6 @@ fpi_device_elanmoc_class_init (FpiDeviceElanmocClass *klass) dev_class->open = elanmoc_open; dev_class->close = elanmoc_close; - dev_class->verify = elanmoc_identify; dev_class->enroll = elanmoc_enroll; dev_class->identify = elanmoc_identify; dev_class->delete = elanmoc_delete_print; diff --git a/libfprint/drivers/focaltech_moc/focaltech_moc.c b/libfprint/drivers/focaltech_moc/focaltech_moc.c index a24bdc7e..8e319f4f 100644 --- a/libfprint/drivers/focaltech_moc/focaltech_moc.c +++ b/libfprint/drivers/focaltech_moc/focaltech_moc.c @@ -807,16 +807,8 @@ focaltech_moc_identify_capture_cb (FpiDeviceFocaltechMoc *self, } else { - if (fpi_device_get_current_action (FP_DEVICE (self)) == FPI_DEVICE_ACTION_VERIFY) - { - fpi_device_verify_report (FP_DEVICE (self), FPI_MATCH_ERROR, NULL, error); - fpi_device_verify_complete (FP_DEVICE (self), NULL); - } - else - { - fpi_device_identify_report (FP_DEVICE (self), NULL, NULL, error); - fpi_device_identify_complete (FP_DEVICE (self), NULL); - } + fpi_device_identify_report (FP_DEVICE (self), NULL, NULL, error); + fpi_device_identify_complete (FP_DEVICE (self), NULL); fpi_ssm_mark_failed (self->task_ssm, fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL)); } @@ -830,50 +822,27 @@ identify_status_report (FpiDeviceFocaltechMoc *self, FpPrint *print, GError *err if (print == NULL) { - if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_IDENTIFY) - { - fpi_device_identify_report (device, NULL, NULL, NULL); - fpi_device_identify_complete (device, NULL); - } - else - { - fpi_device_verify_report (device, FPI_MATCH_FAIL, NULL, NULL); - fpi_device_verify_complete (device, NULL); - } + fpi_device_identify_report (device, NULL, NULL, NULL); + fpi_device_identify_complete (device, NULL); } else { - if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_IDENTIFY) - { - GPtrArray *prints; - gboolean found = FALSE; - guint index; + GPtrArray *prints; + gboolean found = FALSE; + guint index; - fpi_device_get_identify_data (device, &prints); - found = g_ptr_array_find_with_equal_func (prints, - print, - (GEqualFunc) fp_print_equal, - &index); + fpi_device_get_identify_data (device, &prints); + found = g_ptr_array_find_with_equal_func (prints, + print, + (GEqualFunc) fp_print_equal, + &index); - if (found) - fpi_device_identify_report (device, g_ptr_array_index (prints, index), print, NULL); - else - fpi_device_identify_report (device, NULL, print, NULL); - - fpi_device_identify_complete (device, NULL); - } + if (found) + fpi_device_identify_report (device, g_ptr_array_index (prints, index), print, NULL); else - { - FpPrint *verify_print = NULL; - fpi_device_get_verify_data (device, &verify_print); + fpi_device_identify_report (device, NULL, print, NULL); - if (fp_print_equal (verify_print, print)) - fpi_device_verify_report (device, FPI_MATCH_SUCCESS, print, NULL); - else - fpi_device_verify_report (device, FPI_MATCH_FAIL, print, NULL); - - fpi_device_verify_complete (device, NULL); - } + fpi_device_identify_complete (device, NULL); } } @@ -2043,7 +2012,6 @@ fpi_device_focaltech_moc_class_init (FpiDeviceFocaltechMocClass *klass) dev_class->probe = focaltech_moc_probe; dev_class->open = focaltech_moc_open; dev_class->close = focaltech_moc_close; - dev_class->verify = focaltech_moc_identify; dev_class->enroll = focaltech_moc_enroll; dev_class->identify = focaltech_moc_identify; dev_class->delete = focaltech_moc_delete_print; diff --git a/libfprint/drivers/fpcmoc/fpc.c b/libfprint/drivers/fpcmoc/fpc.c index 42954908..975dde15 100644 --- a/libfprint/drivers/fpcmoc/fpc.c +++ b/libfprint/drivers/fpcmoc/fpc.c @@ -1355,19 +1355,17 @@ fpc_enroll_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error) /****************************************************************************** * - * fpc_verify_xxx function + * fpc_identify_xxx function * *****************************************************************************/ static void -fpc_verify_cb (FpiDeviceFpcMoc *self, - void *data, - GError *error) +fpc_identify_cb (FpiDeviceFpcMoc *self, + void *data, + GError *error) { g_autoptr(GPtrArray) templates = NULL; FpDevice *device = FP_DEVICE (self); - gboolean found = FALSE; - FpiDeviceAction current_action; FpiByteReader reader; gint32 status; guint32 identity_type; @@ -1394,18 +1392,11 @@ fpc_verify_cb (FpiDeviceFpcMoc *self, return; } - current_action = fpi_device_get_current_action (device); - - g_assert (current_action == FPI_DEVICE_ACTION_VERIFY || - current_action == FPI_DEVICE_ACTION_IDENTIFY); - if ((status == 0) && (subfactor == FPC_SUBTYPE_RESERVED) && (identity_type == FPC_IDENTITY_TYPE_RESERVED) && (identity_size <= SECURITY_MAX_SID_SIZE)) { FpPrint *match = NULL; - FpPrint *print = NULL; - gint cnt = 0; fpc_fid_data_t fid_data = {0}; fid_data.subfactor = subfactor; @@ -1421,62 +1412,36 @@ fpc_verify_cb (FpiDeviceFpcMoc *self, match = fpc_print_from_data (self, &fid_data); - if (current_action == FPI_DEVICE_ACTION_VERIFY) - { - templates = g_ptr_array_sized_new (1); - fpi_device_get_verify_data (device, &print); - g_ptr_array_add (templates, print); - } - else - { - fpi_device_get_identify_data (device, &templates); - g_ptr_array_ref (templates); - } + fpi_device_get_identify_data (device, &templates); + g_ptr_array_ref (templates); - for (cnt = 0; cnt < templates->len; cnt++) - { - print = g_ptr_array_index (templates, cnt); + guint matching_index; - if (fp_print_equal (print, match)) - { - found = TRUE; - break; - } - } - - if (found) + if (g_ptr_array_find_with_equal_func (templates, match, + (GEqualFunc) fp_print_equal, &matching_index)) { - if (current_action == FPI_DEVICE_ACTION_VERIFY) - fpi_device_verify_report (device, FPI_MATCH_SUCCESS, match, error); - else - fpi_device_identify_report (device, print, match, error); + FpPrint *print = g_ptr_array_index (templates, matching_index); + + fpi_device_identify_report (device, print, match, error); fpi_ssm_mark_completed (self->task_ssm); return; } } - if (!found) - { - if (current_action == FPI_DEVICE_ACTION_VERIFY) - fpi_device_verify_report (device, FPI_MATCH_FAIL, NULL, error); - else - fpi_device_identify_report (device, NULL, NULL, error); - } - - /* This is the last state for verify/identify */ + fpi_device_identify_report (device, NULL, NULL, error); fpi_ssm_mark_completed (self->task_ssm); } static void -fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device) +fpc_identify_sm_run_state (FpiSsm *ssm, FpDevice *device) { FpiDeviceFpcMoc *self = FPI_DEVICE_FPCMOC (device); CommandData cmd_data = {0}; switch (fpi_ssm_get_cur_state (ssm)) { - case FPC_VERIFY_CAPTURE: + case FPC_IDENTIFY_CAPTURE: { guint8 buf[4]; FpiByteWriter writer; @@ -1499,7 +1464,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device) } break; - case FPC_VERIFY_GET_IMG: + case FPC_IDENTIFY_GET_IMG: { cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA; cmd_data.request = FPC_CMD_GET_IMG; @@ -1513,7 +1478,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device) } break; - case FPC_VERIFY_IDENTIFY: + case FPC_IDENTIFY_IDENTIFY: { gsize recv_data_len = sizeof (FPC_IDENTIFY); cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE; @@ -1522,13 +1487,13 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device) cmd_data.index = 0x0; cmd_data.data = NULL; cmd_data.data_len = recv_data_len; - cmd_data.callback = fpc_verify_cb; + cmd_data.callback = fpc_identify_cb; fpc_sensor_cmd (self, FALSE, &cmd_data); } break; - case FPC_VERIFY_CANCEL: + case FPC_IDENTIFY_CANCEL: { cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE; cmd_data.request = FPC_CMD_ABORT; @@ -1545,24 +1510,16 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device) } static void -fpc_verify_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error) +fpc_identify_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error) { FpiDeviceFpcMoc *self = FPI_DEVICE_FPCMOC (dev); fp_info ("Verify_identify complete!"); if (error && error->domain == FP_DEVICE_RETRY) - { - if (fpi_device_get_current_action (dev) == FPI_DEVICE_ACTION_VERIFY) - fpi_device_verify_report (dev, FPI_MATCH_ERROR, NULL, g_steal_pointer (&error)); - else - fpi_device_identify_report (dev, NULL, NULL, g_steal_pointer (&error)); - } + fpi_device_identify_report (dev, NULL, NULL, g_steal_pointer (&error)); - if (fpi_device_get_current_action (dev) == FPI_DEVICE_ACTION_VERIFY) - fpi_device_verify_complete (dev, g_steal_pointer (&error)); - else - fpi_device_identify_complete (dev, g_steal_pointer (&error)); + fpi_device_identify_complete (dev, g_steal_pointer (&error)); self->task_ssm = NULL; } @@ -1920,17 +1877,17 @@ fpc_dev_close (FpDevice *device) } static void -fpc_dev_verify_identify (FpDevice *device) +fpc_dev_identify (FpDevice *device) { FpiDeviceFpcMoc *self = FPI_DEVICE_FPCMOC (device); fp_dbg ("%s enter -->", G_STRFUNC); - self->task_ssm = fpi_ssm_new_full (device, fpc_verify_sm_run_state, - FPC_VERIFY_NUM_STATES, - FPC_VERIFY_CANCEL, - "verify_identify"); + self->task_ssm = fpi_ssm_new_full (device, fpc_identify_sm_run_state, + FPC_IDENTIFY_NUM_STATES, + FPC_IDENTIFY_CANCEL, + "identify"); - fpi_ssm_start (self->task_ssm, fpc_verify_ssm_done); + fpi_ssm_start (self->task_ssm, fpc_identify_ssm_done); } static void @@ -1986,7 +1943,7 @@ fpc_dev_suspend (FpDevice *device) fp_dbg ("%s enter -->", G_STRFUNC); - if (action != FPI_DEVICE_ACTION_VERIFY && action != FPI_DEVICE_ACTION_IDENTIFY) + if (action != FPI_DEVICE_ACTION_IDENTIFY) { fpi_device_suspend_complete (device, fpi_device_error_new (FP_DEVICE_ERROR_NOT_SUPPORTED)); return; @@ -2006,7 +1963,7 @@ fpc_dev_resume (FpDevice *device) fp_dbg ("%s enter -->", G_STRFUNC); - if (action != FPI_DEVICE_ACTION_VERIFY && action != FPI_DEVICE_ACTION_IDENTIFY) + if (action != FPI_DEVICE_ACTION_IDENTIFY) { g_assert_not_reached (); fpi_device_resume_complete (device, fpi_device_error_new (FP_DEVICE_ERROR_NOT_SUPPORTED)); @@ -2118,8 +2075,7 @@ fpi_device_fpcmoc_class_init (FpiDeviceFpcMocClass *klass) dev_class->enroll = fpc_dev_enroll; dev_class->delete = fpc_dev_template_delete; dev_class->list = fpc_dev_template_list; - dev_class->verify = fpc_dev_verify_identify; - dev_class->identify = fpc_dev_verify_identify; + dev_class->identify = fpc_dev_identify; dev_class->suspend = fpc_dev_suspend; dev_class->resume = fpc_dev_resume; dev_class->clear_storage = fpc_dev_clear_storage; diff --git a/libfprint/drivers/fpcmoc/fpc.h b/libfprint/drivers/fpcmoc/fpc.h index 70d64320..a8c5c6cf 100644 --- a/libfprint/drivers/fpcmoc/fpc.h +++ b/libfprint/drivers/fpcmoc/fpc.h @@ -207,11 +207,11 @@ typedef enum { } FpcEnrollState; typedef enum { - FPC_VERIFY_CAPTURE = 0, - FPC_VERIFY_GET_IMG, - FPC_VERIFY_IDENTIFY, - FPC_VERIFY_CANCEL, - FPC_VERIFY_NUM_STATES, + FPC_IDENTIFY_CAPTURE = 0, + FPC_IDENTIFY_GET_IMG, + FPC_IDENTIFY_IDENTIFY, + FPC_IDENTIFY_CANCEL, + FPC_IDENTIFY_NUM_STATES, } FpcVerifyState; typedef enum { diff --git a/libfprint/drivers/goodixmoc/goodix.c b/libfprint/drivers/goodixmoc/goodix.c index 7c059ce9..5126667d 100644 --- a/libfprint/drivers/goodixmoc/goodix.c +++ b/libfprint/drivers/goodixmoc/goodix.c @@ -19,6 +19,7 @@ +#include "glib.h" #define FP_COMPONENT "goodixmoc" #include "drivers_api.h" @@ -393,13 +394,13 @@ fp_pwr_btn_shield_cb (FpiDeviceGoodixMoc *self, } /****************************************************************************** * - * fp_verify_xxxx Function + * fp_identify_xxxx Function * *****************************************************************************/ static void -fp_verify_capture_cb (FpiDeviceGoodixMoc *self, - gxfp_cmd_response_t *resp, - GError *error) +fp_identify_capture_cb (FpiDeviceGoodixMoc *self, + gxfp_cmd_response_t *resp, + GError *error) { if (error) { @@ -432,9 +433,9 @@ fp_verify_capture_cb (FpiDeviceGoodixMoc *self, } static void -fp_verify_cb (FpiDeviceGoodixMoc *self, - gxfp_cmd_response_t *resp, - GError *error) +fp_identify_cb (FpiDeviceGoodixMoc *self, + gxfp_cmd_response_t *resp, + GError *error) { FpDevice *device = FP_DEVICE (self); FpPrint *new_scan = NULL; @@ -445,45 +446,30 @@ fp_verify_cb (FpiDeviceGoodixMoc *self, fpi_ssm_mark_failed (self->task_ssm, error); return; } + if (resp->verify.match) { + GPtrArray *templates = NULL; + guint matching_index; + + fpi_device_get_identify_data (device, &templates); new_scan = fp_print_from_template (self, &resp->verify.template); - if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY) - { - fpi_device_get_verify_data (device, &matching); - if (!fp_print_equal (matching, new_scan)) - matching = NULL; - } - else - { - GPtrArray *templates = NULL; - fpi_device_get_identify_data (device, &templates); - - for (gint i = 0; i < templates->len; i++) - { - if (fp_print_equal (g_ptr_array_index (templates, i), new_scan)) - { - matching = g_ptr_array_index (templates, i); - break; - } - } - } + if (g_ptr_array_find_with_equal_func (templates, new_scan, + (GEqualFunc) fp_print_equal, + &matching_index)) + matching = g_ptr_array_index (templates, matching_index); } - if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY) - fpi_device_verify_report (device, matching ? FPI_MATCH_SUCCESS : FPI_MATCH_FAIL, new_scan, error); - else - fpi_device_identify_report (device, matching, new_scan, error); + fpi_device_identify_report (device, matching, new_scan, error); fpi_ssm_next_state (self->task_ssm); - } static void -fp_verify_finger_mode_cb (FpiDeviceGoodixMoc *self, - gxfp_cmd_response_t *resp, - GError *error) +fp_identify_finger_mode_cb (FpiDeviceGoodixMoc *self, + gxfp_cmd_response_t *resp, + GError *error) { if (error) { @@ -493,7 +479,7 @@ fp_verify_finger_mode_cb (FpiDeviceGoodixMoc *self, /* if reach max timeout(5sec) finger not up, try again */ if (resp->finger_status.status == GX_ERROR_WAIT_FINGER_UP_TIMEOUT) { - fpi_ssm_jump_to_state (self->task_ssm, GOODIX_VERIFY_WAIT_FINGER_UP); + fpi_ssm_jump_to_state (self->task_ssm, GOODIX_IDENTIFY_WAIT_FINGER_UP); return; } else if (resp->finger_status.status != GX_SUCCESS) @@ -510,7 +496,7 @@ fp_verify_finger_mode_cb (FpiDeviceGoodixMoc *self, } static void -fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device) +fp_identify_sm_run_state (FpiSsm *ssm, FpDevice *device) { FpiDeviceGoodixMoc *self = FPI_DEVICE_GOODIXMOC (device); guint8 param[3] = { 0 }; @@ -522,7 +508,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device) switch (fpi_ssm_get_cur_state (ssm)) { - case GOODIX_VERIFY_PWR_BTN_SHIELD_ON: + case GOODIX_IDENTIFY_PWR_BTN_SHIELD_ON: goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_ON, false, NULL, @@ -530,7 +516,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device) fp_pwr_btn_shield_cb); break; - case GOODIX_VERIFY_CAPTURE: + case GOODIX_IDENTIFY_CAPTURE: fpi_device_report_finger_status_changes (device, FP_FINGER_STATUS_NEEDED, FP_FINGER_STATUS_NONE); @@ -538,29 +524,29 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device) true, (const guint8 *) ¶m, G_N_ELEMENTS (param), - fp_verify_capture_cb); + fp_identify_capture_cb); break; - case GOODIX_VERIFY_IDENTIFY: + case GOODIX_IDENTIFY_IDENTIFY: goodix_sensor_cmd (self, MOC_CMD0_IDENTIFY, MOC_CMD1_DEFAULT, false, (const guint8 *) nonce, TEMPLATE_ID_SIZE, - fp_verify_cb); + fp_identify_cb); break; - case GOODIX_VERIFY_WAIT_FINGER_UP: + case GOODIX_IDENTIFY_WAIT_FINGER_UP: { guint8 dummy = 0; goodix_sensor_cmd (self, MOC_CMD0_FINGER_MODE, MOC_CMD1_SET_FINGER_UP, true, &dummy, 1, - fp_verify_finger_mode_cb); + fp_identify_finger_mode_cb); } break; - case GOODIX_VERIFY_PWR_BTN_SHIELD_OFF: + case GOODIX_IDENTIFY_PWR_BTN_SHIELD_OFF: goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_OFF, false, NULL, @@ -572,25 +558,16 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device) } static void -fp_verify_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error) +fp_identify_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error) { FpiDeviceGoodixMoc *self = FPI_DEVICE_GOODIXMOC (dev); fp_info ("Verify complete!"); if (error && error->domain == FP_DEVICE_RETRY) - { - if (fpi_device_get_current_action (dev) == FPI_DEVICE_ACTION_VERIFY) - fpi_device_verify_report (dev, FPI_MATCH_ERROR, NULL, g_steal_pointer (&error)); - else - fpi_device_identify_report (dev, NULL, NULL, g_steal_pointer (&error)); - } + fpi_device_identify_report (dev, NULL, NULL, g_steal_pointer (&error)); - if (fpi_device_get_current_action (dev) == FPI_DEVICE_ACTION_VERIFY) - fpi_device_verify_complete (dev, error); - - else - fpi_device_identify_complete (dev, error); + fpi_device_identify_complete (dev, error); self->task_ssm = NULL; } @@ -1557,16 +1534,16 @@ gx_fp_exit (FpDevice *device) static void -gx_fp_verify_identify (FpDevice *device) +gx_fp_identify (FpDevice *device) { FpiDeviceGoodixMoc *self = FPI_DEVICE_GOODIXMOC (device); - self->task_ssm = fpi_ssm_new_full (device, fp_verify_sm_run_state, - GOODIX_VERIFY_NUM_STATES, - GOODIX_VERIFY_PWR_BTN_SHIELD_OFF, - "verify"); + self->task_ssm = fpi_ssm_new_full (device, fp_identify_sm_run_state, + GOODIX_IDENTIFY_NUM_STATES, + GOODIX_IDENTIFY_PWR_BTN_SHIELD_OFF, + "identify"); - fpi_ssm_start (self->task_ssm, fp_verify_ssm_done); + fpi_ssm_start (self->task_ssm, fp_identify_ssm_done); } @@ -1730,8 +1707,7 @@ fpi_device_goodixmoc_class_init (FpiDeviceGoodixMocClass *klass) dev_class->delete = gx_fp_template_delete; dev_class->clear_storage = gx_fp_template_delete_all; dev_class->list = gx_fp_template_list; - dev_class->verify = gx_fp_verify_identify; - dev_class->identify = gx_fp_verify_identify; + dev_class->identify = gx_fp_identify; fpi_device_class_auto_initialize_features (dev_class); dev_class->features |= FP_DEVICE_FEATURE_DUPLICATES_CHECK; diff --git a/libfprint/drivers/goodixmoc/goodix.h b/libfprint/drivers/goodixmoc/goodix.h index ba7fce27..3d67ea0e 100644 --- a/libfprint/drivers/goodixmoc/goodix.h +++ b/libfprint/drivers/goodixmoc/goodix.h @@ -55,10 +55,10 @@ typedef enum { } GoodixEnrollState; typedef enum { - GOODIX_VERIFY_PWR_BTN_SHIELD_ON = 0, - GOODIX_VERIFY_CAPTURE, - GOODIX_VERIFY_IDENTIFY, - GOODIX_VERIFY_WAIT_FINGER_UP, - GOODIX_VERIFY_PWR_BTN_SHIELD_OFF, - GOODIX_VERIFY_NUM_STATES, + GOODIX_IDENTIFY_PWR_BTN_SHIELD_ON = 0, + GOODIX_IDENTIFY_CAPTURE, + GOODIX_IDENTIFY_IDENTIFY, + GOODIX_IDENTIFY_WAIT_FINGER_UP, + GOODIX_IDENTIFY_PWR_BTN_SHIELD_OFF, + GOODIX_IDENTIFY_NUM_STATES, } GoodixVerifyState; diff --git a/libfprint/drivers/mafpmoc/mafpmoc.c b/libfprint/drivers/mafpmoc/mafpmoc.c index c760ffa6..5dd0d8ab 100644 --- a/libfprint/drivers/mafpmoc/mafpmoc.c +++ b/libfprint/drivers/mafpmoc/mafpmoc.c @@ -1429,9 +1429,9 @@ fp_enroll_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error) static void -fp_verify_tpl_table_cb (FpiDeviceMafpmoc *self, - mafp_cmd_response_t *resp, - GError *error) +fp_identify_tpl_table_cb (FpiDeviceMafpmoc *self, + mafp_cmd_response_t *resp, + GError *error) { if (error) { @@ -1448,13 +1448,13 @@ fp_verify_tpl_table_cb (FpiDeviceMafpmoc *self, } static void -fp_verify_get_image_cb (FpiDeviceMafpmoc *self, - mafp_cmd_response_t *resp, - GError *error) +fp_identify_get_image_cb (FpiDeviceMafpmoc *self, + mafp_cmd_response_t *resp, + GError *error) { g_autoptr(GError) local_error = NULL; FpDevice *dev = FP_DEVICE (self); - MapfVerifyState nextState = MAPF_VERIFY_GET_IMAGE; + MapfIdentifyState nextState = MAPF_IDENTIFY_GET_IMAGE; if (error) { @@ -1474,16 +1474,16 @@ fp_verify_get_image_cb (FpiDeviceMafpmoc *self, fp_dbg ("wait finger down state %d", resp->result); if (resp->result == MAFP_RE_GET_IMAGE_SUCCESS) { - nextState = MAPF_VERIFY_GENERATE_FEATURE; + nextState = MAPF_IDENTIFY_GENERATE_FEATURE; } else if (resp->result == MAFP_RE_GET_IMAGE_NONE) { self->capture_cnt++; fp_dbg ("self->capture_cnt %d", self->capture_cnt); if (self->capture_cnt > MAFP_IMAGE_ERR_TRRIGER) - nextState = MAPF_VERIFY_REFRESH_INT_PARA; + nextState = MAPF_IDENTIFY_REFRESH_INT_PARA; else - nextState = MAPF_VERIFY_DETECT_MODE; + nextState = MAPF_IDENTIFY_DETECT_MODE; } } else if (self->press_state == MAFP_PRESS_WAIT_UP) @@ -1491,13 +1491,13 @@ fp_verify_get_image_cb (FpiDeviceMafpmoc *self, fp_dbg ("wait finger up state %d", resp->result); if (resp->result == MAFP_RE_GET_IMAGE_SUCCESS) { - nextState = MAPF_VERIFY_GET_IMAGE; + nextState = MAPF_IDENTIFY_GET_IMAGE; } else if (resp->result == MAFP_RE_GET_IMAGE_NONE) { self->press_state = MAFP_PRESS_WAIT_DOWN; fpi_device_report_finger_status (dev, FP_FINGER_STATUS_NONE | FP_FINGER_STATUS_NEEDED); - nextState = MAPF_VERIFY_CHECK_INT_PARA; + nextState = MAPF_IDENTIFY_CHECK_INT_PARA; } } @@ -1505,9 +1505,9 @@ fp_verify_get_image_cb (FpiDeviceMafpmoc *self, } static void -fp_verify_gen_feature_cb (FpiDeviceMafpmoc *self, - mafp_cmd_response_t *resp, - GError *error) +fp_identify_gen_feature_cb (FpiDeviceMafpmoc *self, + mafp_cmd_response_t *resp, + GError *error) { if (error) { @@ -1521,12 +1521,12 @@ fp_verify_gen_feature_cb (FpiDeviceMafpmoc *self, { self->enroll_identify_index = 0; self->press_state = MAFP_PRESS_WAIT_UP; - fpi_ssm_jump_to_state (self->task_ssm, MAPF_VERIFY_SEARCH_STEP); + fpi_ssm_jump_to_state (self->task_ssm, MAPF_IDENTIFY_SEARCH_STEP); } else { self->press_state = MAFP_PRESS_WAIT_UP; - fpi_ssm_jump_to_state (self->task_ssm, MAPF_VERIFY_GET_IMAGE); + fpi_ssm_jump_to_state (self->task_ssm, MAPF_IDENTIFY_GET_IMAGE); } } @@ -1539,13 +1539,13 @@ mafp_scl_ctl_cb (FpiUsbTransfer *transfer, if (error) fp_dbg ("control transfer out fail, %s", error->message); - fpi_ssm_jump_to_state (transfer->ssm, MAPF_VERIFY_EXIT); + fpi_ssm_jump_to_state (transfer->ssm, MAPF_IDENTIFY_EXIT); } static void -fp_verify_get_tpl_info_cb (FpiDeviceMafpmoc *self, - mafp_cmd_response_t *resp, - GError *error) +fp_identify_get_tpl_info_cb (FpiDeviceMafpmoc *self, + mafp_cmd_response_t *resp, + GError *error) { g_autoptr(GError) local_error = NULL; FpDevice *dev = FP_DEVICE (self); @@ -1577,27 +1577,18 @@ fp_verify_get_tpl_info_cb (FpiDeviceMafpmoc *self, memcpy (tpl.uid, resp->tpl_info.uid, sizeof (resp->tpl_info.uid)); new_scan = mafp_print_from_template (self, &tpl); } + if (new_scan != NULL) { - if (fpi_device_get_current_action (dev) == FPI_DEVICE_ACTION_VERIFY) - { - fpi_device_get_verify_data (dev, &matching); - if (!fp_print_equal (matching, new_scan)) - matching = NULL; - } - else - { - GPtrArray *templates = NULL; - fpi_device_get_identify_data (dev, &templates); - for (int i = 0; i < templates->len; i++) - { - if (fp_print_equal (g_ptr_array_index (templates, i), new_scan)) - { - matching = g_ptr_array_index (templates, i); - break; - } - } - } + GPtrArray *templates = NULL; + guint matching_index; + + fpi_device_get_identify_data (dev, &templates); + + if (g_ptr_array_find_with_equal_func (templates, new_scan, + (GEqualFunc) fp_print_equal, + &matching_index)) + matching = g_ptr_array_index (templates, matching_index); } } @@ -1609,13 +1600,13 @@ fp_verify_get_tpl_info_cb (FpiDeviceMafpmoc *self, mafp_sensor_control (self, 0x8C, 0x00, mafp_scl_ctl_cb, NULL, 0); return; } - fpi_ssm_jump_to_state (self->task_ssm, MAPF_VERIFY_EXIT); + fpi_ssm_jump_to_state (self->task_ssm, MAPF_IDENTIFY_EXIT); } static void -fp_verify_search_step_cb (FpiDeviceMafpmoc *self, - mafp_cmd_response_t *resp, - GError *error) +fp_identify_search_step_cb (FpiDeviceMafpmoc *self, + mafp_cmd_response_t *resp, + GError *error) { GPtrArray *prints = NULL; FpDevice *dev = FP_DEVICE (self); @@ -1630,23 +1621,20 @@ fp_verify_search_step_cb (FpiDeviceMafpmoc *self, if (resp->result == MAFP_SUCCESS) { fp_dbg ("identify ok, search_id: %d", self->search_id); - fpi_ssm_jump_to_state (self->task_ssm, MAPF_VERIFY_GET_TEMPLATE_INFO); + fpi_ssm_jump_to_state (self->task_ssm, MAPF_IDENTIFY_GET_TEMPLATE_INFO); } else { fp_dbg ("identify fail"); - if (fpi_device_get_current_action (dev) == FPI_DEVICE_ACTION_IDENTIFY) + fpi_device_get_identify_data (dev, &prints); + self->enroll_identify_index++; + if (self->enroll_identify_index < prints->len) { - fpi_device_get_identify_data (dev, &prints); - self->enroll_identify_index++; - if (self->enroll_identify_index < prints->len) - { - fpi_ssm_jump_to_state (self->task_ssm, MAPF_VERIFY_SEARCH_STEP); - return; - } + fpi_ssm_jump_to_state (self->task_ssm, MAPF_IDENTIFY_SEARCH_STEP); + return; } self->search_id = G_MAXUINT16; - fpi_ssm_jump_to_state (self->task_ssm, MAPF_VERIFY_GET_TEMPLATE_INFO); + fpi_ssm_jump_to_state (self->task_ssm, MAPF_IDENTIFY_GET_TEMPLATE_INFO); } } @@ -1673,7 +1661,7 @@ mafp_get_startup_result_cb (FpiUsbTransfer *transfer, { self->search_id = transfer->buffer[2] * 256 + transfer->buffer[1]; usleep (1000 * 1000); - fpi_ssm_jump_to_state (transfer->ssm, MAPF_VERIFY_GET_TEMPLATE_INFO); + fpi_ssm_jump_to_state (transfer->ssm, MAPF_IDENTIFY_GET_TEMPLATE_INFO); return; } } @@ -1681,33 +1669,7 @@ mafp_get_startup_result_cb (FpiUsbTransfer *transfer, } static void -fp_verify_int_check_cb (FpiDeviceMafpmoc *self, - mafp_cmd_response_t *resp, - GError *error) -{ - if (error) - { - fpi_ssm_mark_failed (self->task_ssm, g_steal_pointer (&error)); - return; - } - fpi_ssm_next_state (self->task_ssm); -} - -static void -fp_verify_int_detect_cb (FpiDeviceMafpmoc *self, - mafp_cmd_response_t *resp, - GError *error) -{ - if (error) - { - fpi_ssm_mark_failed (self->task_ssm, g_steal_pointer (&error)); - return; - } - fpi_ssm_next_state (self->task_ssm); -} - -static void -fp_verify_int_refresh_cb (FpiDeviceMafpmoc *self, +fp_identify_int_check_cb (FpiDeviceMafpmoc *self, mafp_cmd_response_t *resp, GError *error) { @@ -1716,15 +1678,41 @@ fp_verify_int_refresh_cb (FpiDeviceMafpmoc *self, fpi_ssm_mark_failed (self->task_ssm, g_steal_pointer (&error)); return; } - self->capture_cnt = 0; - fpi_ssm_jump_to_state (self->task_ssm, MAPF_VERIFY_GET_IMAGE); + fpi_ssm_next_state (self->task_ssm); } static void -fp_verify_enable_int_cb (FpiUsbTransfer *transfer, - FpDevice *device, - gpointer user_data, - GError *error) +fp_identify_int_detect_cb (FpiDeviceMafpmoc *self, + mafp_cmd_response_t *resp, + GError *error) +{ + if (error) + { + fpi_ssm_mark_failed (self->task_ssm, g_steal_pointer (&error)); + return; + } + fpi_ssm_next_state (self->task_ssm); +} + +static void +fp_identify_int_refresh_cb (FpiDeviceMafpmoc *self, + mafp_cmd_response_t *resp, + GError *error) +{ + if (error) + { + fpi_ssm_mark_failed (self->task_ssm, g_steal_pointer (&error)); + return; + } + self->capture_cnt = 0; + fpi_ssm_jump_to_state (self->task_ssm, MAPF_IDENTIFY_GET_IMAGE); +} + +static void +fp_identify_enable_int_cb (FpiUsbTransfer *transfer, + FpDevice *device, + gpointer user_data, + GError *error) { if (error) { @@ -1735,24 +1723,24 @@ fp_verify_enable_int_cb (FpiUsbTransfer *transfer, } static void -fp_verify_disable_int_cb (FpiUsbTransfer *transfer, - FpDevice *device, - gpointer user_data, - GError *error) +fp_identify_disable_int_cb (FpiUsbTransfer *transfer, + FpDevice *device, + gpointer user_data, + GError *error) { if (error) { fpi_ssm_mark_failed (transfer->ssm, g_steal_pointer (&error)); return; } - fpi_ssm_jump_to_state (transfer->ssm, MAPF_VERIFY_GET_IMAGE); + fpi_ssm_jump_to_state (transfer->ssm, MAPF_IDENTIFY_GET_IMAGE); } static void -fp_verify_wait_int_cb (FpiUsbTransfer *transfer, - FpDevice *device, - gpointer user_data, - GError *error) +fp_identify_wait_int_cb (FpiUsbTransfer *transfer, + FpDevice *device, + gpointer user_data, + GError *error) { FpiDeviceMafpmoc *self = FPI_DEVICE_MAFPMOC (device); @@ -1761,7 +1749,7 @@ fp_verify_wait_int_cb (FpiUsbTransfer *transfer, fp_dbg ("code %d", error->code); if (error->code == G_USB_DEVICE_ERROR_TIMED_OUT) { - fpi_ssm_jump_to_state (self->task_ssm, MAPF_VERIFY_GET_IMAGE); + fpi_ssm_jump_to_state (self->task_ssm, MAPF_IDENTIFY_GET_IMAGE); g_clear_error (&error); return; } @@ -1783,7 +1771,7 @@ fp_verify_wait_int_cb (FpiUsbTransfer *transfer, } static void -fp_verify_wait_int (FpiDeviceMafpmoc *self) +fp_identify_wait_int (FpiDeviceMafpmoc *self) { fp_dbg ("wait interrupt"); FpiUsbTransfer *transfer = fpi_usb_transfer_new (FP_DEVICE (self)); @@ -1792,12 +1780,12 @@ fp_verify_wait_int (FpiDeviceMafpmoc *self) fpi_usb_transfer_submit (transfer, 30 * 60 * 1000, fpi_device_get_cancellable (FP_DEVICE (self)), - fp_verify_wait_int_cb, + fp_identify_wait_int_cb, NULL); } static void -fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device) +fp_identify_sm_run_state (FpiSsm *ssm, FpDevice *device) { FpiDeviceMafpmoc *self = FPI_DEVICE_MAFPMOC (device); uint8_t para[PACKAGE_DATA_SIZE_MAX] = { 0 }; @@ -1806,110 +1794,97 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device) switch(fpi_ssm_get_cur_state (ssm)) { - case MAPF_VERIFY_PWR_BTN_SHIELD_ON: + case MAPF_IDENTIFY_PWR_BTN_SHIELD_ON: mafp_pwr_btn_shield_on (self, 1); break; - case MAPF_VERIFY_TEMPLATE_TABLE: + case MAPF_IDENTIFY_TEMPLATE_TABLE: para[0] = 0; /* page no. */ - mafp_sensor_cmd (self, MOC_CMD_GET_TEMPLATE_TABLE, (const uint8_t *) ¶, 1, fp_verify_tpl_table_cb); + mafp_sensor_cmd (self, MOC_CMD_GET_TEMPLATE_TABLE, (const uint8_t *) ¶, 1, fp_identify_tpl_table_cb); break; - case MAPF_VERIFY_GET_STARTUP_RESULT: + case MAPF_IDENTIFY_GET_STARTUP_RESULT: mafp_sensor_control (self, 0x8D, 0x00, mafp_get_startup_result_cb, NULL, 0); break; - case MAPF_VERIFY_GET_IMAGE: - mafp_sensor_cmd (self, MOC_CMD_GET_IMAGE, NULL, 0, fp_verify_get_image_cb); + case MAPF_IDENTIFY_GET_IMAGE: + mafp_sensor_cmd (self, MOC_CMD_GET_IMAGE, NULL, 0, fp_identify_get_image_cb); break; - case MAPF_VERIFY_CHECK_INT_PARA: + case MAPF_IDENTIFY_CHECK_INT_PARA: para[0] = MAFP_SLEEP_INT_CHECK; - mafp_sensor_cmd (self, MOC_CMD_SLEEP, para, 1, fp_verify_int_check_cb); + mafp_sensor_cmd (self, MOC_CMD_SLEEP, para, 1, fp_identify_int_check_cb); break; - case MAPF_VERIFY_DETECT_MODE: + case MAPF_IDENTIFY_DETECT_MODE: para[0] = MAFP_SLEEP_INT_WAIT; - mafp_sensor_cmd (self, MOC_CMD_SLEEP, para, 1, fp_verify_int_detect_cb); + mafp_sensor_cmd (self, MOC_CMD_SLEEP, para, 1, fp_identify_int_detect_cb); break; - case MAPF_VERIFY_ENABLE_INT: - mafp_sensor_control (self, 0x89, 1, fp_verify_enable_int_cb, NULL, 0); + case MAPF_IDENTIFY_ENABLE_INT: + mafp_sensor_control (self, 0x89, 1, fp_identify_enable_int_cb, NULL, 0); break; - case MAPF_VERIFY_WAIT_INT: - fp_verify_wait_int (self); + case MAPF_IDENTIFY_WAIT_INT: + fp_identify_wait_int (self); break; - case MAPF_VERIFY_DISBALE_INT: - mafp_sensor_control (self, 0x89, 0, fp_verify_disable_int_cb, NULL, 0); + case MAPF_IDENTIFY_DISBALE_INT: + mafp_sensor_control (self, 0x89, 0, fp_identify_disable_int_cb, NULL, 0); break; - case MAPF_VERIFY_REFRESH_INT_PARA: + case MAPF_IDENTIFY_REFRESH_INT_PARA: fp_dbg ("refresh param"); para[0] = MAFP_SLEEP_INT_REFRESH; - mafp_sensor_cmd (self, MOC_CMD_SLEEP, para, 1, fp_verify_int_refresh_cb); + mafp_sensor_cmd (self, MOC_CMD_SLEEP, para, 1, fp_identify_int_refresh_cb); break; - case MAPF_VERIFY_GENERATE_FEATURE: + case MAPF_IDENTIFY_GENERATE_FEATURE: para[0] = 1; /* buffer id */ - mafp_sensor_cmd (self, MOC_CMD_GEN_FEATURE, (const uint8_t *) ¶, 1, fp_verify_gen_feature_cb); + mafp_sensor_cmd (self, MOC_CMD_GEN_FEATURE, (const uint8_t *) ¶, 1, fp_identify_gen_feature_cb); break; - case MAPF_VERIFY_SEARCH_STEP: - if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY) + case MAPF_IDENTIFY_SEARCH_STEP: + fpi_device_get_identify_data (device, &prints); + if (!prints || prints->len == 0) { - fpi_device_get_verify_data (device, &print); - if (!print) - { - self->search_id = G_MAXUINT16; - fpi_ssm_jump_to_state (self->task_ssm, MAPF_VERIFY_GET_TEMPLATE_INFO); - break; - } - } - else - { - fpi_device_get_identify_data (device, &prints); - if (!prints || prints->len == 0) - { - self->search_id = G_MAXUINT16; - fpi_ssm_jump_to_state (self->task_ssm, MAPF_VERIFY_GET_TEMPLATE_INFO); - break; - } - print = g_ptr_array_index (prints, self->enroll_identify_index); + self->search_id = G_MAXUINT16; + fpi_ssm_jump_to_state (self->task_ssm, MAPF_IDENTIFY_GET_TEMPLATE_INFO); + break; } + print = g_ptr_array_index (prints, self->enroll_identify_index); mafp_template_t tpl = mafp_template_from_print (print); self->search_id = tpl.id; para[0] = (tpl.id >> 8) & 0xff; para[1] = tpl.id & 0xff; - mafp_sensor_cmd (self, MOC_CMD_MATCH_WITHFID, (const uint8_t *) ¶, 2, fp_verify_search_step_cb); + mafp_sensor_cmd (self, MOC_CMD_MATCH_WITHFID, (const uint8_t *) ¶, 2, fp_identify_search_step_cb); break; - case MAPF_VERIFY_GET_TEMPLATE_INFO: + case MAPF_IDENTIFY_GET_TEMPLATE_INFO: if (self->search_id == G_MAXUINT16) { mafp_cmd_response_t resp; resp.result = 1; - fp_verify_get_tpl_info_cb (self, &resp, NULL); + fp_identify_get_tpl_info_cb (self, &resp, NULL); } else { para[0] = (self->search_id >> 8) & 0xff; /* fp id high */ para[1] = self->search_id & 0xff; /* fp id low */ - mafp_sensor_cmd (self, MOC_CMD_GET_TEMPLATE_INFO, (const uint8_t *) ¶, 2, fp_verify_get_tpl_info_cb); + mafp_sensor_cmd (self, MOC_CMD_GET_TEMPLATE_INFO, (const uint8_t *) ¶, 2, fp_identify_get_tpl_info_cb); } break; - case MAPF_VERIFY_EXIT: + case MAPF_IDENTIFY_EXIT: mafp_pwr_btn_shield_on (self, 0); break; } } static void -fp_verify_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error) +fp_identify_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error) { - fp_dbg ("verify completed"); + fp_dbg ("identify completed"); FpiDeviceMafpmoc *self = FPI_DEVICE_MAFPMOC (dev); g_autoptr(FpPrint) new_print = g_steal_pointer (&self->identify_new_print); FpPrint *match_print = g_steal_pointer (&self->identify_match_print); @@ -1918,10 +1893,7 @@ fp_verify_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error) if (error && error->domain == FP_DEVICE_RETRY) { - if (fpi_device_get_current_action (dev) == FPI_DEVICE_ACTION_VERIFY) - fpi_device_verify_report (dev, FPI_MATCH_ERROR, NULL, g_steal_pointer (&error)); - else - fpi_device_identify_report (dev, NULL, NULL, g_steal_pointer (&error)); + fpi_device_identify_report (dev, NULL, NULL, g_steal_pointer (&error)); return; } @@ -1932,20 +1904,11 @@ fp_verify_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error) return; } - if (fpi_device_get_current_action (dev) == FPI_DEVICE_ACTION_VERIFY) - { - fpi_device_verify_report (dev, match_print ? FPI_MATCH_SUCCESS : FPI_MATCH_FAIL, - g_steal_pointer (&new_print), NULL); - fpi_device_verify_complete (dev, NULL); - } - else - { - fpi_device_identify_report (dev, match_print, - self->enroll_dupl_del_state ? - g_steal_pointer (&new_print) : NULL, - NULL); - fpi_device_identify_complete (dev, NULL); - } + fpi_device_identify_report (dev, match_print, + self->enroll_dupl_del_state ? + g_steal_pointer (&new_print) : NULL, + NULL); + fpi_device_identify_complete (dev, NULL); } static void @@ -2460,7 +2423,7 @@ mafp_enroll (FpDevice *device) } static void -mafp_verify_identify (FpDevice *device) +mafp_identify (FpDevice *device) { FpiDeviceMafpmoc *self = FPI_DEVICE_MAFPMOC (device); @@ -2471,14 +2434,14 @@ mafp_verify_identify (FpDevice *device) self->identify_match_print = NULL; g_clear_object (&self->identify_new_print); - self->task_ssm = fpi_ssm_new_full (device, fp_verify_sm_run_state, - MAPF_VERIFY_STATES, - MAPF_VERIFY_EXIT, - "verify"); + self->task_ssm = fpi_ssm_new_full (device, fp_identify_sm_run_state, + MAPF_IDENTIFY_STATES, + MAPF_IDENTIFY_EXIT, + "identify"); if (!PRINT_SSM_DEBUG) fpi_ssm_silence_debug (self->task_ssm); - fpi_ssm_start (self->task_ssm, fp_verify_ssm_done); + fpi_ssm_start (self->task_ssm, fp_identify_ssm_done); } static void @@ -2579,8 +2542,7 @@ fpi_device_mafpmoc_class_init (FpiDeviceMafpmocClass *klass) dev_class->probe = mafp_probe; dev_class->enroll = mafp_enroll; dev_class->cancel = mafp_cancel; - dev_class->verify = mafp_verify_identify; - dev_class->identify = mafp_verify_identify; + dev_class->identify = mafp_identify; dev_class->delete = mafp_template_delete; dev_class->clear_storage = mafp_template_delete_all; dev_class->list = mafp_template_list; diff --git a/libfprint/drivers/mafpmoc/mafpmoc.h b/libfprint/drivers/mafpmoc/mafpmoc.h index f1c4b8cf..097d1cc0 100644 --- a/libfprint/drivers/mafpmoc/mafpmoc.h +++ b/libfprint/drivers/mafpmoc/mafpmoc.h @@ -138,22 +138,22 @@ typedef enum { } MapfEnrollState; typedef enum { - MAPF_VERIFY_PWR_BTN_SHIELD_ON = 0, - MAPF_VERIFY_TEMPLATE_TABLE, - MAPF_VERIFY_GET_STARTUP_RESULT, - MAPF_VERIFY_GET_IMAGE, - MAPF_VERIFY_CHECK_INT_PARA, - MAPF_VERIFY_DETECT_MODE, - MAPF_VERIFY_ENABLE_INT, - MAPF_VERIFY_WAIT_INT, - MAPF_VERIFY_DISBALE_INT, - MAPF_VERIFY_REFRESH_INT_PARA, - MAPF_VERIFY_GENERATE_FEATURE, - MAPF_VERIFY_SEARCH_STEP, //match assigned id - MAPF_VERIFY_GET_TEMPLATE_INFO, - MAPF_VERIFY_EXIT, - MAPF_VERIFY_STATES, -} MapfVerifyState; + MAPF_IDENTIFY_PWR_BTN_SHIELD_ON = 0, + MAPF_IDENTIFY_TEMPLATE_TABLE, + MAPF_IDENTIFY_GET_STARTUP_RESULT, + MAPF_IDENTIFY_GET_IMAGE, + MAPF_IDENTIFY_CHECK_INT_PARA, + MAPF_IDENTIFY_DETECT_MODE, + MAPF_IDENTIFY_ENABLE_INT, + MAPF_IDENTIFY_WAIT_INT, + MAPF_IDENTIFY_DISBALE_INT, + MAPF_IDENTIFY_REFRESH_INT_PARA, + MAPF_IDENTIFY_GENERATE_FEATURE, + MAPF_IDENTIFY_SEARCH_STEP, //match assigned id + MAPF_IDENTIFY_GET_TEMPLATE_INFO, + MAPF_IDENTIFY_EXIT, + MAPF_IDENTIFY_STATES, +} MapfIdentifyState; typedef enum { MAPF_LIST_TEMPLATE_TABLE = 0,