From de6fc99ef5a1767fae07fbea9bc384f512639e57 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Sun, 28 Oct 2007 00:17:16 +0000 Subject: split off libavahi-gobject into its own directory git-svn-id: file:///home/lennart/svn/public/avahi/trunk@1564 941a03a8-eaeb-0310-b9a0-b1bbd8fe43fe --- avahi-gobject/ga-client.c | 256 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 256 insertions(+) create mode 100644 avahi-gobject/ga-client.c (limited to 'avahi-gobject/ga-client.c') diff --git a/avahi-gobject/ga-client.c b/avahi-gobject/ga-client.c new file mode 100644 index 0000000..d34933f --- /dev/null +++ b/avahi-gobject/ga-client.c @@ -0,0 +1,256 @@ +/* + * ga-client.c - Source for GaClient + * Copyright (C) 2005 Collabora Ltd. + * + * 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 St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#include +#include + +#include "ga-client.h" + +#include "ga-client-enumtypes.h" +#include "ga-errors.h" + +/* FIXME what to do about glib-malloc ? */ +#include +#include +#include +#include + +G_DEFINE_TYPE(GaClient, ga_client, G_TYPE_OBJECT) + +/* signal enum */ +enum { + STATE_CHANGED, + LAST_SIGNAL +}; + +static guint signals[LAST_SIGNAL] = { 0 }; + +/* properties */ +enum { + PROP_STATE = 1, + PROP_FLAGS +}; + +/* private structure */ +typedef struct _GaClientPrivate GaClientPrivate; + +struct _GaClientPrivate { + AvahiGLibPoll *poll; + GaClientFlags flags; + GaClientState state; + gboolean dispose_has_run; +}; + +#define GA_CLIENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GA_TYPE_CLIENT, GaClientPrivate)) + +static void ga_client_init(GaClient * self) { + GaClientPrivate *priv = GA_CLIENT_GET_PRIVATE(self); + /* allocate any data required by the object here */ + self->avahi_client = NULL; + priv->state = GA_CLIENT_STATE_NOT_STARTED; + priv->flags = GA_CLIENT_FLAG_NO_FLAGS; +} + +static void ga_client_dispose(GObject * object); +static void ga_client_finalize(GObject * object); + +static void ga_client_set_property(GObject * object, + guint property_id, + const GValue * value, GParamSpec * pspec) { + GaClient *client = GA_CLIENT(object); + GaClientPrivate *priv = GA_CLIENT_GET_PRIVATE(client); + + switch (property_id) { + case PROP_FLAGS: + g_assert(client->avahi_client == NULL); + priv->flags = g_value_get_enum(value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + break; + } +} + +static void ga_client_get_property(GObject * object, + guint property_id, + GValue * value, GParamSpec * pspec) { + GaClient *client = GA_CLIENT(object); + GaClientPrivate *priv = GA_CLIENT_GET_PRIVATE(client); + + switch (property_id) { + case PROP_STATE: + g_value_set_enum(value, priv->state); + break; + case PROP_FLAGS: + g_value_set_enum(value, priv->flags); + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec); + break; + } +} + +static void ga_client_class_init(GaClientClass * ga_client_class) { + GObjectClass *object_class = G_OBJECT_CLASS(ga_client_class); + GParamSpec *param_spec; + + g_type_class_add_private(ga_client_class, sizeof (GaClientPrivate)); + + + object_class->dispose = ga_client_dispose; + object_class->finalize = ga_client_finalize; + + object_class->set_property = ga_client_set_property; + object_class->get_property = ga_client_get_property; + + param_spec = g_param_spec_enum("state", "Client state", + "The state of the Avahi client", + GA_TYPE_CLIENT_STATE, + GA_CLIENT_STATE_NOT_STARTED, + G_PARAM_READABLE | + G_PARAM_STATIC_NAME | + G_PARAM_STATIC_BLURB); + g_object_class_install_property(object_class, PROP_STATE, param_spec); + + param_spec = g_param_spec_enum("flags", "Client flags", + "The flags the Avahi client is started with", + GA_TYPE_CLIENT_FLAGS, + GA_CLIENT_FLAG_NO_FLAGS, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY | + G_PARAM_STATIC_NAME | + G_PARAM_STATIC_BLURB); + g_object_class_install_property(object_class, PROP_FLAGS, param_spec); + + signals[STATE_CHANGED] = + g_signal_new("state-changed", + G_OBJECT_CLASS_TYPE(ga_client_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED, + 0, + NULL, NULL, + g_cclosure_marshal_VOID__ENUM, + G_TYPE_NONE, 1, GA_TYPE_CLIENT_STATE); + +} + +void ga_client_dispose(GObject * object) { + GaClient *self = GA_CLIENT(object); + GaClientPrivate *priv = GA_CLIENT_GET_PRIVATE(self); + + if (priv->dispose_has_run) + return; + + priv->dispose_has_run = TRUE; + + if (self->avahi_client) { + avahi_client_free(self->avahi_client); + self->avahi_client = NULL; + } + if (priv->poll) { + avahi_glib_poll_free(priv->poll); + priv->poll = NULL; + } + + /* release any references held by the object here */ + if (G_OBJECT_CLASS(ga_client_parent_class)->dispose) + G_OBJECT_CLASS(ga_client_parent_class)->dispose(object); +} + +void ga_client_finalize(GObject * object) { + + /* free any data held directly by the object here */ + G_OBJECT_CLASS(ga_client_parent_class)->finalize(object); +} + +GaClient *ga_client_new(GaClientFlags flags) { + return g_object_new(GA_TYPE_CLIENT, "flags", flags, NULL); +} + +static GQuark detail_for_state(AvahiClientState state) { + static struct { + AvahiClientState state; + const gchar *name; + GQuark quark; + } states[] = { + { AVAHI_CLIENT_S_REGISTERING, "registering", 0}, + { AVAHI_CLIENT_S_RUNNING, "running", 0}, + { AVAHI_CLIENT_S_COLLISION, "collistion", 0}, + { AVAHI_CLIENT_FAILURE, "failure", 0}, + { AVAHI_CLIENT_CONNECTING, "connecting", 0}, + { 0, NULL, 0} + }; + int i; + + for (i = 0; states[i].name != NULL; i++) { + if (state != states[i].state) + continue; + + if (!states[i].quark) + states[i].quark = g_quark_from_static_string(states[i].name); +/* printf("Detail: %s\n", states[i].name); */ + return states[i].quark; + } + g_assert_not_reached(); +} + +static void _avahi_client_cb(AvahiClient * c, AvahiClientState state, void *data) { + GaClient *self = GA_CLIENT(data); + GaClientPrivate *priv = GA_CLIENT_GET_PRIVATE(self); + +/* printf("CLIENT CB: %d\n", state); */ + + /* Avahi can call the callback before return from _client_new */ + if (self->avahi_client == NULL) + self->avahi_client = c; + + g_assert(c == self->avahi_client); + priv->state = state; + g_signal_emit(self, signals[STATE_CHANGED], + detail_for_state(state), state); +} + +gboolean ga_client_start(GaClient * client, GError ** error) { + GaClientPrivate *priv = GA_CLIENT_GET_PRIVATE(client); + AvahiClient *aclient; + int aerror; + + g_assert(client->avahi_client == NULL); + g_assert(priv->poll == NULL); + + avahi_set_allocator(avahi_glib_allocator()); + + priv->poll = avahi_glib_poll_new(NULL, G_PRIORITY_DEFAULT); + + aclient = avahi_client_new(avahi_glib_poll_get(priv->poll), + priv->flags, + _avahi_client_cb, client, &aerror); + if (aclient == NULL) { + if (error != NULL) { + *error = g_error_new(GA_ERRORS, aerror, + "Failed to create avahi client: %s", + avahi_strerror(aerror)); + } + return FALSE; + } + client->avahi_client = aclient; + return TRUE; +} -- cgit