Move to object oriented model

There is now a single Manager class shared between all apps.
Apps then share a collection of Device objects.

.gitignore

@@ -11,7 +11,8 @@ config.log
 config.status
 .deps
 client-bindings.h
-server-bindings.h
+*-dbus-glue.h
 demo
 *.o
 fprintd
+*.swp

examples/Makefile.am

-BUILT_SOURCES = client-bindings.h
+BUILT_SOURCES = manager-dbus-glue.h device-dbus-glue.h
 noinst_HEADERS = $(BUILT_SOURCES)
 CLEANFILES = $(BUILT_SOURCES)
 
@@ -8,7 +8,9 @@ demo_SOURCES = demo.c
 demo_CFLAGS = $(AM_CFLAGS) $(DBUS_GLIB_CFLAGS)
 demo_LDADD = $(DBUS_GLIB_LIBS)
 
-client-bindings.h: ../src/fprintd.xml
-	dbus-binding-tool --prefix=fprint --mode=glib-client $< --output=$@
+manager-dbus-glue.h: ../src/manager.xml
+	dbus-binding-tool --prefix=fprint_manager --mode=glib-client $< --output=$@
 
+device-dbus-glue.h: ../src/device.xml
+	dbus-binding-tool --prefix=fprint_device --mode=glib-client $< --output=$@
 

examples/demo.c

@@ -19,9 +19,10 @@
 
 #include <stdlib.h>
 #include <dbus/dbus-glib-bindings.h>
-#include "client-bindings.h"
+#include "manager-dbus-glue.h"
+#include "device-dbus-glue.h"
 
-static DBusGProxy *proxy = NULL;
+static DBusGProxy *manager = NULL;
 static DBusGConnection *connection = NULL;
 
 enum fp_verify_result {
@@ -94,7 +95,7 @@ static const char *fingerstr(guint32 fingernum)
 	}
 }
 
-static void create_proxy(void)
+static void create_manager(void)
 {
 	GError *error = NULL;
 
@@ -102,49 +103,51 @@ static void create_proxy(void)
 	if (connection == NULL)
 		g_error("Failed to connect to session bus: %s", error->message);
 
-	proxy = dbus_g_proxy_new_for_name_owner(connection,
-		"net.reactivated.Fprint", "/net/reactivated/Fprint",
-		"net.reactivated.Fprint", &error);
-	if (proxy == NULL)
+	manager = dbus_g_proxy_new_for_name_owner(connection,
+		"net.reactivated.Fprint", "/net/reactivated/Fprint/Manager",
+		"net.reactivated.Fprint.Manager", &error);
+	if (manager == NULL)
 		g_error("Failed to create proxy: %s", error->message);
 }
 
-static guint32 open_device(void)
+static DBusGProxy *open_device(void)
 {
 	GError *error = NULL;
-	GArray *device_ids;
-	char **drvnames;
-	char **fullnames;
+	GPtrArray *devices;
+	gchar *path;
+	DBusGProxy *dev;
 	guint i;
-	guint32 device_id;
 
-	if (!net_reactivated_Fprint_list_devices(proxy, &device_ids, &drvnames,
-			&fullnames, &error))
+	if (!net_reactivated_Fprint_Manager_get_devices(manager, &devices, &error))
 		g_error("list_devices failed: %s", error->message);
 	
-	if (device_ids->len == 0) {
+	if (devices->len == 0) {
 		g_print("No devices found\n");
 		exit(1);
 	}
 
-	g_print("found %d devices\n", device_ids->len);
-	for (i = 0; i < device_ids->len; i++) {
-		g_print("Device #%d: %s (%s)\n", g_array_index(device_ids, guint32, i),
-			fullnames[i], drvnames[i]);
+	g_print("found %d devices\n", devices->len);
+	for (i = 0; i < devices->len; i++) {
+		path = g_ptr_array_index(devices, i);
+		g_print("Device at %s\n", path);
 	}
 
-	device_id = g_array_index(device_ids, int, 0);
-	g_strfreev(drvnames);
-	g_strfreev(fullnames);
-	g_array_free(device_ids, TRUE);
+	path = g_ptr_array_index(devices, 0);
+	g_print("Using device %s\n", path);
 
-	g_print("using device #%d\n", device_id);
-	if (!net_reactivated_Fprint_claim_device(proxy, device_id, &error))
+	/* FIXME use for_name_owner?? */
+	dev = dbus_g_proxy_new_for_name(connection, "net.reactivated.Fprint",
+		path, "net.reactivated.Fprint.Device");
+	
+	g_ptr_array_foreach(devices, (GFunc) g_free, NULL);
+	g_ptr_array_free(devices, TRUE);
+
+	if (!net_reactivated_Fprint_Device_claim(dev, &error))
 		g_error("failed to claim device: %s", error->message);
-	return device_id;
+	return dev;
 }
 
-static guint32 find_finger(guint32 device_id)
+static guint32 find_finger(DBusGProxy *dev)
 {
 	GError *error = NULL;
 	GArray *fingers;
@@ -152,7 +155,7 @@ static guint32 find_finger(guint32 device_id)
 	int fingernum;
 	guint32 print_id;
 
-	if (!net_reactivated_Fprint_list_enrolled_fingers(proxy, 0, &fingers, &error))
+	if (!net_reactivated_Fprint_Device_list_enrolled_fingers(dev, &fingers, &error))
 		g_error("ListEnrolledFingers failed: %s", error->message);
 
 	if (fingers->len == 0) {
@@ -170,64 +173,64 @@ static guint32 find_finger(guint32 device_id)
 	g_array_free(fingers, TRUE);
 
 	g_print("Verifying: %s\n", fingerstr(fingernum));
-	if (!net_reactivated_Fprint_load_print_data(proxy, device_id, fingernum, &print_id, &error))
+	if (!net_reactivated_Fprint_Device_load_print_data(dev, fingernum, &print_id, &error))
 		g_error("LoadPrintData failed: %s", error->message);
 
 	return print_id;
 }
 
-static int do_verify(guint32 device_id, guint32 print_id)
+static int do_verify(DBusGProxy *dev, guint32 print_id)
 {
 	GError *error;
 	gboolean more_results;
 	int result;
 
-	if (!net_reactivated_Fprint_verify_start(proxy, device_id, print_id, &error))
+	if (!net_reactivated_Fprint_Device_verify_start(dev, print_id, &error))
 		g_error("VerifyStart failed: %s", error->message);
 
 	do {
-		if (!net_reactivated_Fprint_get_verify_result(proxy, device_id, &result, &more_results, &error))
+		if (!net_reactivated_Fprint_Device_get_verify_result(dev, &result, &more_results, &error))
 			g_error("GetVerifyResult failed: %s", error->message);
 
 		g_print("Verify result: %s (%d)\n", verify_result_str(result), result);
 	} while (result != VERIFY_NO_MATCH && result != VERIFY_MATCH);
 
-	if (!net_reactivated_Fprint_verify_stop(proxy, device_id, &error))
+	if (!net_reactivated_Fprint_Device_verify_stop(dev, &error))
 		g_error("VerifyStop failed: %s", error->message);
 
 	return result;
 }
 
-static void unload_print(guint32 device_id, guint32 print_id)
+static void unload_print(DBusGProxy *dev, guint32 print_id)
 {
 	GError *error = NULL;
-	if (!net_reactivated_Fprint_unload_print_data(proxy, device_id, print_id, &error))
+	if (!net_reactivated_Fprint_Device_unload_print_data(dev, print_id, &error))
 		g_error("UnloadPrint failed: %s", error->message);
 }
 
-static void release_device(guint32 device_id)
+static void release_device(DBusGProxy *dev)
 {
 	GError *error = NULL;
-	if (!net_reactivated_Fprint_release_device(proxy, device_id, &error))
+	if (!net_reactivated_Fprint_Device_release(dev, &error))
 		g_error("ReleaseDevice failed: %s", error->message);
 }
 
 int main(int argc, char **argv)
 {
 	GMainLoop *loop;
-	guint32 device_id;
+	DBusGProxy *dev;
 	guint32 print_id;
 	int verify_result;
 
 	g_type_init();
 	loop = g_main_loop_new(NULL, FALSE);
-	create_proxy();
+	create_manager();
 
-	device_id = open_device();
-	print_id = find_finger(device_id);
-	verify_result = do_verify(device_id, print_id);
-	unload_print(device_id, print_id);
-	release_device(device_id);
+	dev = open_device();
+	print_id = find_finger(dev);
+	verify_result = do_verify(dev, print_id);
+	unload_print(dev, print_id);
+	release_device(dev);
 	return 0;
 }
 

src/Makefile.am

-BUILT_SOURCES = server-bindings.h
+BUILT_SOURCES = manager-dbus-glue.h device-dbus-glue.h
 noinst_HEADERS = $(BUILT_SOURCES)
 
 CLEANFILES = $(BUILT_SOURCES)
@@ -6,10 +6,13 @@ EXTRA_DIST = fprintd.xml
 
 bin_PROGRAMS = fprintd
 
-fprintd_SOURCES = main.c
+fprintd_SOURCES = main.c manager.c device.c
 fprintd_LDADD = $(GLIB_LIBS) $(DBUS_GLIB_LIBS) $(FPRINT_LIBS)
 fprintd_CFLAGS = $(AM_CFLAGS) $(GLIB_CFLAGS) $(DBUS_GLIB_CFLAGS) $(FPRINT_CFLAGS)
 
-server-bindings.h: fprintd.xml
-	dbus-binding-tool --prefix=fprint --mode=glib-server $< --output=$@
+manager-dbus-glue.h: manager.xml
+	dbus-binding-tool --prefix=fprint_manager --mode=glib-server $< --output=$@
+
+device-dbus-glue.h: device.xml
+	dbus-binding-tool --prefix=fprint_device --mode=glib-server $< --output=$@
 

src/device.c

+/*
+ * /net/reactivated/Fprint/Device/foo object implementation
+ * Copyright (C) 2008 Daniel Drake <dsd@gentoo.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program 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 General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <dbus/dbus-glib-bindings.h>
+#include <glib.h>
+#include <libfprint/fprint.h>
+#include <glib-object.h>
+
+#include "fprintd.h"
+
+static gboolean fprint_device_claim(FprintDevice *rdev,
+	DBusGMethodInvocation *context);
+static gboolean fprint_device_release(FprintDevice *rdev,
+	DBusGMethodInvocation *context);
+static gboolean fprint_device_list_enrolled_fingers(FprintDevice *rdev,
+	GArray **fingers, GError **error);
+static gboolean fprint_device_load_print_data(FprintDevice *rdev,
+	guint32 finger_num, guint32 *print_id, GError **error);
+static gboolean fprint_device_unload_print_data(FprintDevice *rdev,
+	guint32 print_id, GError **error);
+static gboolean fprint_device_verify_start(FprintDevice *rdev,
+	guint32 print_id, GError **error);
+static gboolean fprint_device_verify_stop(FprintDevice *rdev,
+	DBusGMethodInvocation *context);
+static gboolean fprint_device_get_verify_result(FprintDevice *rdev,
+	DBusGMethodInvocation *context);
+
+#include "device-dbus-glue.h"
+
+struct session_data {
+	/* a list of pending verify results to be returned via GetVerifyResult() */
+	GList *verify_results;
+
+	/* method invocation for async ClaimDevice() */
+	DBusGMethodInvocation *context_claim_device;
+
+	/* method invocation for async ReleaseDevice() */
+	DBusGMethodInvocation *context_release_device;
+
+	/* method invocation for async GetVerifyResult() */
+	DBusGMethodInvocation *context_get_verify_result;
+
+	/* a list of loaded prints */
+	GSList *loaded_prints;
+};
+
+struct verify_result {
+	int result;
+	struct fp_img *img;
+};
+
+struct loaded_print {
+	guint32 id;
+	struct fp_print_data *data;
+};
+
+struct FprintDevicePrivate {
+	guint32 id;
+	struct fp_dscv_dev *ddev;
+	struct fp_dev *dev;
+	struct session_data *session;
+};
+
+typedef struct FprintDevicePrivate FprintDevicePrivate;
+
+#define DEVICE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), FPRINT_TYPE_DEVICE, FprintDevicePrivate))
+
+enum fprint_device_properties {
+	FPRINT_DEVICE_CONSTRUCT_DDEV = 1,
+};
+
+static GObjectClass *parent_class = NULL;
+static guint32 last_id = ~0;
+
+static void device_finalize(GObject *object)
+{
+	/* FIXME close and stuff */
+}
+
+static void device_set_property(GObject *object, guint property_id,
+	const GValue *value, GParamSpec *pspec)
+{
+	FprintDevice *self = (FprintDevice *) object;
+	FprintDevicePrivate *priv = DEVICE_GET_PRIVATE(self);
+
+	switch (property_id) {
+	case FPRINT_DEVICE_CONSTRUCT_DDEV:
+		priv->ddev = g_value_get_pointer(value);
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
+		break;
+	}
+}
+
+static void device_class_init(FprintDeviceClass *klass)
+{
+	GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
+	GParamSpec *pspec;
+
+	dbus_g_object_type_install_info(FPRINT_TYPE_DEVICE,
+		&dbus_glib_fprint_device_object_info);
+	parent_class = g_type_class_peek_parent(klass);
+
+	gobject_class->finalize = device_finalize;
+	gobject_class->set_property = device_set_property;
+
+	pspec = g_param_spec_pointer("discovered-dev", "Discovered device",
+		"Set discovered device construction property",
+		G_PARAM_CONSTRUCT_ONLY | G_PARAM_WRITABLE);
+	g_object_class_install_property(gobject_class,
+		FPRINT_DEVICE_CONSTRUCT_DDEV, pspec);
+
+	g_type_class_add_private(klass, sizeof(FprintDevicePrivate));
+}
+
+static void device_init(GTypeInstance *instance, gpointer g_class)
+{
+	FprintDevice *self = (FprintDevice *) instance;
+	FprintDevicePrivate *priv = DEVICE_GET_PRIVATE(self);
+	priv->id = ++last_id;
+}
+
+GType fprint_device_get_type(void)
+{
+	static GType type = 0;
+	if (type == 0) {
+		static const GTypeInfo info = {
+			sizeof(FprintDeviceClass),
+			NULL,   /* base_init */
+			NULL,   /* base_finalize */
+			(GClassInitFunc) device_class_init,
+			NULL,   /* class_finalize */
+			NULL,   /* class_data */
+			sizeof(FprintDevice),
+			0,      /* n_preallocs */
+			device_init,
+		};
+		type = g_type_register_static(G_TYPE_OBJECT, "FprintDeviceType",
+			&info, 0);
+	}
+	return type;
+}
+
+FprintDevice *fprint_device_new(struct fp_dscv_dev *ddev)
+{
+	return g_object_new(FPRINT_TYPE_DEVICE, "discovered-dev", ddev, NULL);	
+}
+
+guint32 _fprint_device_get_id(FprintDevice *rdev)
+{
+	return DEVICE_GET_PRIVATE(rdev)->id;
+}
+
+static void dev_open_cb(struct fp_dev *dev, int status, void *user_data)
+{
+	FprintDevice *rdev = user_data;
+	FprintDevicePrivate *priv = DEVICE_GET_PRIVATE(rdev);
+	struct session_data *session = priv->session;
+
+	g_message("device %d claim status %d", priv->id, status);
+
+	if (status != 0) {
+		GError *error;
+		g_set_error(&error, FPRINT_ERROR, FPRINT_ERROR_CLAIM_DEVICE,
+			"Open failed with error %d", status);
+		dbus_g_method_return_error(session->context_claim_device, error);
+		return;
+	}
+
+	priv->dev = dev;
+	dbus_g_method_return(session->context_claim_device);
+}
+
+static gboolean fprint_device_claim(FprintDevice *rdev,
+	DBusGMethodInvocation *context)
+{
+	FprintDevicePrivate *priv = DEVICE_GET_PRIVATE(rdev);
+	GError *error = NULL;
+	int r;
+
+	g_message("claiming device %d", priv->id);
+	priv->session = g_slice_new0(struct session_data);
+	priv->session->context_claim_device = context;
+
+	r = fp_async_dev_open(priv->ddev, dev_open_cb, rdev);
+	if (r < 0) {
+		g_slice_free(struct session_data, priv->session);
+		priv->session = NULL;
+		g_set_error(&error, FPRINT_ERROR, FPRINT_ERROR_CLAIM_DEVICE,
+			"Could not attempt device open, error %d", r);
+		dbus_g_method_return_error(context, error);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static void dev_close_cb(struct fp_dev *dev, void *user_data)
+{
+	FprintDevice *rdev = user_data;
+	FprintDevicePrivate *priv = DEVICE_GET_PRIVATE(rdev);
+	struct session_data *session = priv->session;
+	DBusGMethodInvocation *context = session->context_release_device;
+
+	priv->dev = NULL;
+	g_slice_free(struct session_data, session);
+	priv->session = NULL;
+
+	g_message("released device %d", priv->id);
+	dbus_g_method_return(context);
+}
+
+static gboolean fprint_device_release(FprintDevice *rdev,
+	DBusGMethodInvocation *context)
+{
+	FprintDevicePrivate *priv = DEVICE_GET_PRIVATE(rdev);
+	struct session_data *session = priv->session;
+	GSList *elem = session->loaded_prints;
+
+	/* Unload any loaded prints */
+	if (elem) {
+		do
+			g_slice_free(struct loaded_print, elem->data);
+		while ((elem = g_slist_next(elem)) != NULL);
+		g_slist_free(session->loaded_prints);
+	}
+
+	session->context_release_device = context;
+	fp_async_dev_close(priv->dev, dev_close_cb, rdev);
+	return TRUE;
+}
+
+static gboolean fprint_device_list_enrolled_fingers(FprintDevice *rdev,
+	GArray **fingers, GError **error)
+{
+	FprintDevicePrivate *priv = DEVICE_GET_PRIVATE(rdev);
+	struct fp_dscv_print **prints;
+	struct fp_dscv_print **print;
+	GArray *ret;
+
+	prints = fp_discover_prints();
+	if (!prints) {
+		g_set_error(error, FPRINT_ERROR, FPRINT_ERROR_DISCOVER_PRINTS,
+			"Failed to discover prints");
+		return FALSE;
+	}
+
+	ret = g_array_new(FALSE, FALSE, sizeof(int));
+	for (print = prints; *print; print++)
+		if (fp_dev_supports_dscv_print(priv->dev, *print)) {
+			int finger = fp_dscv_print_get_finger(*print);
+			ret = g_array_append_val(ret, finger);
+		}
+
+	fp_dscv_prints_free(prints);
+	*fingers = ret;
+	return TRUE;
+}
+
+static gboolean fprint_device_load_print_data(FprintDevice *rdev,
+	guint32 finger_num, guint32 *print_id, GError **error)
+{
+	FprintDevicePrivate *priv = DEVICE_GET_PRIVATE(rdev);
+	struct session_data *session = priv->session;
+	struct loaded_print *lprint;
+	struct fp_dscv_print **dprints = fp_discover_prints();
+	struct fp_dscv_print **dprint;
+	struct fp_dscv_print *selected_print = NULL;
+	struct fp_print_data *data;
+	int r;
+
+	if (!dprints) {
+		g_set_error(error, FPRINT_ERROR, FPRINT_ERROR_DISCOVER_PRINTS,
+			"Failed to discover prints");
+		return FALSE;
+	}
+
+	for (dprint = dprints; *dprint; dprint++)
+		if (fp_dev_supports_dscv_print(priv->dev, *dprint)
+				&& fp_dscv_print_get_finger(*dprint) == finger_num) {
+			selected_print = *dprint;
+			break;
+		}
+	
+	if (!selected_print) {
+		fp_dscv_prints_free(dprints);
+		g_set_error(error, FPRINT_ERROR, FPRINT_ERROR_PRINT_NOT_FOUND,
+			"Print not found");
+		return FALSE;
+	}
+
+	r = fp_print_data_from_dscv_print(selected_print, &data);
+	fp_dscv_prints_free(dprints);
+	if (r < 0) {
+		g_set_error(error, FPRINT_ERROR, FPRINT_ERROR_PRINT_LOAD,
+			"Print load failed with error %d", r);
+		return FALSE;
+	}
+
+	lprint = g_slice_new(struct loaded_print);
+	lprint->data = data;
+	lprint->id = ++last_id;
+	session->loaded_prints = g_slist_prepend(session->loaded_prints, lprint);
+
+	g_message("load print data finger %d for device %d = %d",
+		finger_num, priv->id, lprint->id);
+	*print_id = lprint->id;
+	return TRUE;
+}
+
+static gboolean fprint_device_unload_print_data(FprintDevice *rdev,
+	guint32 print_id, GError **error)
+{
+	FprintDevicePrivate *priv = DEVICE_GET_PRIVATE(rdev);
+	struct session_data *session = priv->session;
+	GSList *elem = session->loaded_prints;
+
+	g_message("unload print data %d for device %d", print_id, priv->id);
+	if (!elem) {
+		g_set_error(error, FPRINT_ERROR, FPRINT_ERROR_NO_SUCH_LOADED_PRINT,
+			"No such loaded print %d", print_id);
+		return FALSE;
+	}
+
+	do {
+		struct loaded_print *print = elem->data;
+		if (print->id != print_id)
+			continue;
+
+		session->loaded_prints = g_slist_delete_link(session->loaded_prints,
+			elem);
+		g_slice_free(struct loaded_print, print);
+		return TRUE;
+	} while ((elem = g_slist_next(elem)) != NULL);
+
+	g_set_error(error, FPRINT_ERROR, FPRINT_ERROR_NO_SUCH_LOADED_PRINT,
+		"No such loaded print %d", print_id);
+	return FALSE;
+}
+
+static void verify_cb(struct fp_dev *dev, int r, struct fp_img *img,
+	void *user_data)
+{
+	struct FprintDevice *rdev = user_data;
+	FprintDevicePrivate *priv = DEVICE_GET_PRIVATE(rdev);
+	struct session_data *session = priv->session;
+	g_message("verify_cb: result %d", r);
+
+	if (session->context_get_verify_result) {
+		/* if we have an app waiting on a verify result, report it
+		 * immediately */
+		dbus_g_method_return(session->context_get_verify_result, r, FALSE);
+		fp_img_free(img);
+		session->context_get_verify_result = NULL;
+	} else {
+		/* otherwise nobody is listening. add it to the queue of pending
+		 * results */
+		struct verify_result *result = g_slice_new(struct verify_result);
+		result->result = r;
+		result->img = img;
+		session->verify_results = g_list_append(session->verify_results,
+			result);
+	}
+}
+
+static gboolean fprint_device_verify_start(FprintDevice *rdev,
+	guint32 print_id, GError **error)
+{
+	FprintDevicePrivate *priv = DEVICE_GET_PRIVATE(rdev);