| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /* | ||
| 2 | * FpImageDevice - An image based fingerprint reader device | ||
| 3 | * Copyright (C) 2019 Benjamin Berg <bberg@redhat.com> | ||
| 4 | * | ||
| 5 | * This library is free software; you can redistribute it and/or | ||
| 6 | * modify it under the terms of the GNU Lesser General Public | ||
| 7 | * License as published by the Free Software Foundation; either | ||
| 8 | * version 2.1 of the License, or (at your option) any later version. | ||
| 9 | * | ||
| 10 | * This library is distributed in the hope that it will be useful, | ||
| 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
| 13 | * Lesser General Public License for more details. | ||
| 14 | * | ||
| 15 | * You should have received a copy of the GNU Lesser General Public | ||
| 16 | * License along with this library; if not, write to the Free Software | ||
| 17 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
| 18 | */ | ||
| 19 | |||
| 20 | #define FP_COMPONENT "image_device" | ||
| 21 | #include "fpi-log.h" | ||
| 22 | |||
| 23 | #include "fp-image-device-private.h" | ||
| 24 | |||
| 25 | #define BOZORTH3_DEFAULT_THRESHOLD 40 | ||
| 26 | |||
| 27 | /** | ||
| 28 | * SECTION: fp-image-device | ||
| 29 | * @title: FpImageDevice | ||
| 30 | * @short_description: Image device subclass | ||
| 31 | * | ||
| 32 | * This is a helper class for the commonly found image based devices. | ||
| 33 | */ | ||
| 34 | |||
| 35 |
3/4✓ Branch 0 (2→3) taken 244 times.
✓ Branch 1 (2→7) taken 3386 times.
✓ Branch 2 (4→5) taken 122 times.
✗ Branch 3 (4→7) not taken.
|
3937 | G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (FpImageDevice, fp_image_device, FP_TYPE_DEVICE) |
| 36 | |||
| 37 | enum { | ||
| 38 | PROP_0, | ||
| 39 | PROP_FPI_STATE, | ||
| 40 | N_PROPS | ||
| 41 | }; | ||
| 42 | |||
| 43 | static GParamSpec *properties[N_PROPS]; | ||
| 44 | |||
| 45 | enum { | ||
| 46 | FPI_STATE_CHANGED, | ||
| 47 | |||
| 48 | LAST_SIGNAL | ||
| 49 | }; | ||
| 50 | |||
| 51 | static guint signals[LAST_SIGNAL] = { 0 }; | ||
| 52 | |||
| 53 | /*******************************************************/ | ||
| 54 | |||
| 55 | /* TODO: | ||
| 56 | * - sanitize_image seems a bit odd, in particular the sizing stuff. | ||
| 57 | **/ | ||
| 58 | |||
| 59 | /* Callbacks/vfuncs */ | ||
| 60 | static void | ||
| 61 | 41 | fp_image_device_open (FpDevice *device) | |
| 62 | { | ||
| 63 | 41 | FpImageDeviceClass *cls = FP_IMAGE_DEVICE_GET_CLASS (device); | |
| 64 | |||
| 65 | /* Nothing special about opening an image device, just | ||
| 66 | * forward the request. */ | ||
| 67 | 41 | cls->img_open (FP_IMAGE_DEVICE (device)); | |
| 68 | 41 | } | |
| 69 | |||
| 70 | static void | ||
| 71 | 41 | fp_image_device_close (FpDevice *device) | |
| 72 | { | ||
| 73 | 41 | FpImageDevice *self = FP_IMAGE_DEVICE (device); | |
| 74 |
1/2✗ Branch 0 (2→3) not taken.
✓ Branch 1 (2→4) taken 41 times.
|
41 | FpImageDeviceClass *cls = FP_IMAGE_DEVICE_GET_CLASS (self); |
| 75 | 41 | FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self); | |
| 76 | |||
| 77 |
1/2✗ Branch 0 (2→3) not taken.
✓ Branch 1 (2→4) taken 41 times.
|
41 | g_assert (priv->active == FALSE); |
| 78 | 41 | cls->img_close (self); | |
| 79 | 41 | } | |
| 80 | |||
| 81 | static void | ||
| 82 | 1 | fp_image_device_cancel_action (FpDevice *device) | |
| 83 | { | ||
| 84 | 1 | FpImageDevice *self = FP_IMAGE_DEVICE (device); | |
| 85 | 1 | FpiDeviceAction action; | |
| 86 | |||
| 87 | 1 | action = fpi_device_get_current_action (device); | |
| 88 | |||
| 89 | /* We can only cancel capture operations, in that case, deactivate and return | ||
| 90 | * an error immediately. */ | ||
| 91 | 1 | if (action == FPI_DEVICE_ACTION_ENROLL || | |
| 92 | action == FPI_DEVICE_ACTION_VERIFY || | ||
| 93 |
1/2✓ Branch 0 (3→4) taken 1 times.
✗ Branch 1 (3→5) not taken.
|
1 | action == FPI_DEVICE_ACTION_IDENTIFY || |
| 94 | action == FPI_DEVICE_ACTION_CAPTURE) | ||
| 95 | 1 | fpi_image_device_deactivate (self, TRUE); | |
| 96 | 1 | } | |
| 97 | |||
| 98 | static void | ||
| 99 | 34 | fp_image_device_start_capture_action (FpDevice *device) | |
| 100 | { | ||
| 101 | 34 | FpImageDevice *self = FP_IMAGE_DEVICE (device); | |
| 102 | 34 | FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self); | |
| 103 | 34 | FpiDeviceAction action; | |
| 104 | 34 | FpiPrintType print_type; | |
| 105 | |||
| 106 | /* There is just one action that we cannot support out | ||
| 107 | * of the box, which is a capture without first waiting | ||
| 108 | * for a finger to be on the device. | ||
| 109 | */ | ||
| 110 | 34 | action = fpi_device_get_current_action (device); | |
| 111 |
2/2✓ Branch 0 (3→4) taken 16 times.
✓ Branch 1 (3→10) taken 18 times.
|
34 | if (action == FPI_DEVICE_ACTION_CAPTURE) |
| 112 | { | ||
| 113 | 16 | gboolean wait_for_finger; | |
| 114 | |||
| 115 | 16 | fpi_device_get_capture_data (device, &wait_for_finger); | |
| 116 | |||
| 117 |
1/2✗ Branch 0 (5→6) not taken.
✓ Branch 1 (5→9) taken 16 times.
|
16 | if (!wait_for_finger) |
| 118 | { | ||
| 119 | ✗ | fpi_device_action_error (device, fpi_device_error_new (FP_DEVICE_ERROR_NOT_SUPPORTED)); | |
| 120 | ✗ | return; | |
| 121 | } | ||
| 122 | } | ||
| 123 |
2/2✓ Branch 0 (10→11) taken 6 times.
✓ Branch 1 (10→16) taken 12 times.
|
18 | else if (action == FPI_DEVICE_ACTION_ENROLL) |
| 124 | { | ||
| 125 | 6 | FpPrint *enroll_print = NULL; | |
| 126 | |||
| 127 | 6 | fpi_device_get_enroll_data (device, &enroll_print); | |
| 128 | 6 | g_object_get (enroll_print, "fpi-type", &print_type, NULL); | |
| 129 |
2/2✓ Branch 0 (13→14) taken 5 times.
✓ Branch 1 (13→15) taken 1 times.
|
6 | if (print_type != FPI_PRINT_NBIS) |
| 130 | 5 | fpi_print_set_type (enroll_print, FPI_PRINT_NBIS); | |
| 131 | } | ||
| 132 | |||
| 133 | 34 | priv->enroll_stage = 0; | |
| 134 | /* The internal state machine guarantees both of these. */ | ||
| 135 |
1/2✗ Branch 0 (16→17) not taken.
✓ Branch 1 (16→18) taken 34 times.
|
34 | g_assert (!priv->finger_present); |
| 136 |
1/2✓ Branch 0 (18→19) taken 34 times.
✗ Branch 1 (18→21) not taken.
|
34 | g_assert (!priv->minutiae_scan_active); |
| 137 | |||
| 138 | /* And activate the device; we rely on fpi_image_device_activate_complete() | ||
| 139 | * to be called when done (or immediately). */ | ||
| 140 | 34 | fpi_image_device_activate (self); | |
| 141 | } | ||
| 142 | |||
| 143 | |||
| 144 | /*********************************************************/ | ||
| 145 | |||
| 146 | static void | ||
| 147 | 44 | fp_image_device_finalize (GObject *object) | |
| 148 | { | ||
| 149 | 44 | FpImageDevice *self = (FpImageDevice *) object; | |
| 150 | 44 | FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self); | |
| 151 | |||
| 152 |
1/2✗ Branch 0 (2→3) not taken.
✓ Branch 1 (2→4) taken 44 times.
|
44 | g_assert (priv->active == FALSE); |
| 153 | |||
| 154 | 44 | G_OBJECT_CLASS (fp_image_device_parent_class)->finalize (object); | |
| 155 | 44 | } | |
| 156 | |||
| 157 | static void | ||
| 158 | ✗ | fp_image_device_default_activate (FpImageDevice *self) | |
| 159 | { | ||
| 160 | ✗ | fpi_image_device_activate_complete (self, NULL); | |
| 161 | ✗ | } | |
| 162 | |||
| 163 | static void | ||
| 164 | ✗ | fp_image_device_default_deactivate (FpImageDevice *self) | |
| 165 | { | ||
| 166 | ✗ | fpi_image_device_deactivate_complete (self, NULL); | |
| 167 | ✗ | } | |
| 168 | |||
| 169 | static void | ||
| 170 | 22 | fp_image_device_get_property (GObject *object, | |
| 171 | guint prop_id, | ||
| 172 | GValue *value, | ||
| 173 | GParamSpec *pspec) | ||
| 174 | { | ||
| 175 | 22 | FpImageDevice *self = FP_IMAGE_DEVICE (object); | |
| 176 | 22 | FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self); | |
| 177 | |||
| 178 |
1/2✓ Branch 0 (2→3) taken 22 times.
✗ Branch 1 (2→5) not taken.
|
22 | switch (prop_id) |
| 179 | { | ||
| 180 | 22 | case PROP_FPI_STATE: | |
| 181 | 22 | g_value_set_enum (value, priv->state); | |
| 182 | 22 | break; | |
| 183 | |||
| 184 | ✗ | default: | |
| 185 | ✗ | G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); | |
| 186 | } | ||
| 187 | 22 | } | |
| 188 | |||
| 189 | static void | ||
| 190 | 44 | fp_image_device_constructed (GObject *obj) | |
| 191 | { | ||
| 192 | 44 | FpImageDevice *self = FP_IMAGE_DEVICE (obj); | |
| 193 | 44 | FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self); | |
| 194 |
2/2✓ Branch 0 (2→3) taken 12 times.
✓ Branch 1 (2→4) taken 32 times.
|
44 | FpImageDeviceClass *cls = FP_IMAGE_DEVICE_GET_CLASS (self); |
| 195 | |||
| 196 | /* Set default threshold. */ | ||
| 197 | 44 | priv->bz3_threshold = BOZORTH3_DEFAULT_THRESHOLD; | |
| 198 |
2/2✓ Branch 0 (2→3) taken 12 times.
✓ Branch 1 (2→4) taken 32 times.
|
44 | if (cls->bz3_threshold > 0) |
| 199 | 12 | priv->bz3_threshold = cls->bz3_threshold; | |
| 200 | |||
| 201 | 44 | G_OBJECT_CLASS (fp_image_device_parent_class)->constructed (obj); | |
| 202 | 44 | } | |
| 203 | |||
| 204 | static void | ||
| 205 | 122 | fp_image_device_class_init (FpImageDeviceClass *klass) | |
| 206 | { | ||
| 207 | 122 | GObjectClass *object_class = G_OBJECT_CLASS (klass); | |
| 208 | 122 | FpDeviceClass *fp_device_class = FP_DEVICE_CLASS (klass); | |
| 209 | |||
| 210 | 122 | object_class->finalize = fp_image_device_finalize; | |
| 211 | 122 | object_class->get_property = fp_image_device_get_property; | |
| 212 | 122 | object_class->constructed = fp_image_device_constructed; | |
| 213 | |||
| 214 | /* Set default enroll stage count. */ | ||
| 215 | 122 | fp_device_class->nr_enroll_stages = IMG_ENROLL_STAGES; | |
| 216 | |||
| 217 | 122 | fp_device_class->open = fp_image_device_open; | |
| 218 | 122 | fp_device_class->close = fp_image_device_close; | |
| 219 | 122 | fp_device_class->enroll = fp_image_device_start_capture_action; | |
| 220 | 122 | fp_device_class->verify = fp_image_device_start_capture_action; | |
| 221 | 122 | fp_device_class->identify = fp_image_device_start_capture_action; | |
| 222 | 122 | fp_device_class->capture = fp_image_device_start_capture_action; | |
| 223 | |||
| 224 | 122 | fp_device_class->cancel = fp_image_device_cancel_action; | |
| 225 | |||
| 226 | 122 | fpi_device_class_auto_initialize_features (fp_device_class); | |
| 227 | 122 | fp_device_class->features |= FP_DEVICE_FEATURE_UPDATE_PRINT; | |
| 228 | |||
| 229 | /* Default implementations */ | ||
| 230 | 122 | klass->activate = fp_image_device_default_activate; | |
| 231 | 122 | klass->deactivate = fp_image_device_default_deactivate; | |
| 232 | |||
| 233 | /** | ||
| 234 | * FpImageDevice::fpi-image-device-state: (skip) | ||
| 235 | * | ||
| 236 | * This property is only for internal purposes. | ||
| 237 | * | ||
| 238 | * Stability: private | ||
| 239 | */ | ||
| 240 | 244 | properties[PROP_FPI_STATE] = | |
| 241 | 122 | g_param_spec_enum ("fpi-image-device-state", | |
| 242 | "Image Device State", | ||
| 243 | "Private: The state of the image device", | ||
| 244 | FPI_TYPE_IMAGE_DEVICE_STATE, | ||
| 245 | FPI_IMAGE_DEVICE_STATE_INACTIVE, | ||
| 246 | G_PARAM_STATIC_STRINGS | G_PARAM_READABLE); | ||
| 247 | |||
| 248 | /** | ||
| 249 | * FpImageDevice::fpi-image-device-state-changed: (skip) | ||
| 250 | * @image_device: A #FpImageDevice | ||
| 251 | * @new_state: The new state of the device | ||
| 252 | * | ||
| 253 | * This signal is only for internal purposes. | ||
| 254 | * | ||
| 255 | * Stability: private | ||
| 256 | */ | ||
| 257 | 244 | signals[FPI_STATE_CHANGED] = | |
| 258 | 122 | g_signal_new ("fpi-image-device-state-changed", | |
| 259 | G_TYPE_FROM_CLASS (object_class), | ||
| 260 | G_SIGNAL_RUN_FIRST, | ||
| 261 | G_STRUCT_OFFSET (FpImageDeviceClass, change_state), | ||
| 262 | NULL, NULL, NULL, | ||
| 263 | G_TYPE_NONE, 1, FPI_TYPE_IMAGE_DEVICE_STATE); | ||
| 264 | |||
| 265 | 122 | g_object_class_install_properties (object_class, N_PROPS, properties); | |
| 266 | 122 | } | |
| 267 | |||
| 268 | static void | ||
| 269 | 44 | fp_image_device_init (FpImageDevice *self) | |
| 270 | { | ||
| 271 | 44 | } | |
| 272 |