system/NetworkManager
system/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager synced 2024-09-16 06:40:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

bluez: enable both BlueZ4 and 5 and select it dynamically at runtime

Browse source 
NMBluezManager is now a proxy and only delegates to either
NMBluez4Manager or NMBluez5Manager. It detects the running BlueZ
version at runtime, and once it decides for one version, it cannot be
changed anymore as long NetworkManager is running.

This means, when switching from BlueZ4 to BlueZ5 or vice versa you have
to restart NetworkManager. This should be acceptable, because it is
not a common use case (most systems won't have both versions installed
anyway) and it greatly simplifies implementation.

Also note that NMBluez4Manager and NMBluez5Manager do not implement a
common interface. NMBluezManager delegates to the correct manager.
Having them share an common interface or base class would not simplify
the code, because NMBluezManager not only delegates, but it also acts as
a proxy until it is decided which BlueZ version is running. So, this
proxy-like behaviour would still be needed. The alternative would be to
merge the functionality of all three NMBluez*Manager classes into one.

This also removes the --enable-bluez4 configure switch, because both
versions are now always enabled.

https://bugzilla.gnome.org/show_bug.cgi?id=709412

Signed-off-by: Thomas Haller <thaller@redhat.com>
This commit is contained in:
Thomas Haller 2013-10-03 01:48:24 +02:00
parent 3344ce9ff6
commit bf5a6ad443
9 changed files with 725 additions and 180 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
configure.ac
View file

@ -267,18 +267,6 @@ else
fi
AC_SUBST(UDEV_BASE_DIR)
# BlueZ
AC_ARG_ENABLE(bluez4, AS_HELP_STRING([--enable-bluez4],
[build with BlueZ 4 support instead of BlueZ 5]),
[enable_bluez4=${enableval}])
if (test "${enable_bluez4}" = "yes"); then
AC_DEFINE(WITH_BLUEZ4, 1, [Define if you have BlueZ 4 support])
else
AC_DEFINE(WITH_BLUEZ4, 0, [Define if you have BlueZ 4 support])
enable_bluez4=no
fi
AM_CONDITIONAL(WITH_BLUEZ4, test "${enable_bluez4}" = "yes")
# systemd unit support
AC_ARG_WITH([systemdsystemunitdir], AS_HELP_STRING([--with-systemdsystemunitdir=DIR],
[Directory for systemd service files]))
@ -826,7 +814,6 @@ echo " modemmanager-1: $with_modem_manager_1"
echo " concheck: $enable_concheck"
echo " libndp: $libndp_location"
echo " libteamdctl: $enable_teamdctl"
echo " bluez 4: $enable_bluez4"
echo
echo "Configuration plugins"

29
src/Makefile.am
View file

@ -49,6 +49,18 @@ NetworkManager_LDADD = libNetworkManager.la $(top_builddir)/libgsystem.la $(LIBN
noinst_LTLIBRARIES = libNetworkManager.la
nm_sources = \
bluez-manager/nm-bluez-common.h \
bluez-manager/nm-bluez-device.c \
bluez-manager/nm-bluez-device.h \
bluez-manager/nm-bluez-manager.c \
bluez-manager/nm-bluez-manager.h \
bluez-manager/nm-bluez4-adapter.c \
bluez-manager/nm-bluez4-adapter.h \
bluez-manager/nm-bluez4-manager.c \
bluez-manager/nm-bluez4-manager.h \
bluez-manager/nm-bluez5-manager.c \
bluez-manager/nm-bluez5-manager.h \
\
config/nm-config.c \
config/nm-config.h \
config/nm-config-device.c \
@ -258,23 +270,6 @@ nm_sources = \
NetworkManagerUtils.c \
NetworkManagerUtils.h
nm_sources += \
bluez-manager/nm-bluez-common.h \
bluez-manager/nm-bluez-device.c \
bluez-manager/nm-bluez-device.h
if WITH_BLUEZ4
nm_sources += \
bluez-manager/nm-bluez4-adapter.h \
bluez-manager/nm-bluez4-adapter.c \
bluez-manager/nm-bluez4-manager.c
bluez-manager/nm-bluez4-manager.h
else
nm_sources += \
bluez-manager/nm-bluez5-manager.c \
bluez-manager/nm-bluez5-manager.h
endif
if WITH_MODEM_MANAGER_1
nm_sources += \
modem-manager/nm-modem-broadband.c \

514
src/bluez-manager/nm-bluez-manager.c Normal file
View file

@ -0,0 +1,514 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/* NetworkManager -- Network link manager
*
* 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.
*
* Copyright (C) 2013 Red Hat, Inc.
*/
#include <signal.h>
#include <string.h>
#include <stdlib.h>
#include <gio/gio.h>
#include "nm-logging.h"
#include "nm-bluez-manager.h"
#include "nm-bluez4-manager.h"
#include "nm-bluez5-manager.h"
#include "nm-bluez-device.h"
#include "nm-bluez-common.h"
#include "nm-dbus-manager.h"
typedef struct {
int bluez_version;
NMConnectionProvider *provider;
NMBluez4Manager *manager4;
NMBluez5Manager *manager5;
guint watch_name_id;
GDBusProxy *introspect_proxy;
GCancellable *async_cancellable;
} NMBluezManagerPrivate;
#define NM_BLUEZ_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_BLUEZ_MANAGER, NMBluezManagerPrivate))
G_DEFINE_TYPE (NMBluezManager, nm_bluez_manager, G_TYPE_OBJECT)
enum {
PROP_0,
PROP_PROVIDER,
LAST_PROP
};
enum {
BDADDR_ADDED,
BDADDR_REMOVED,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0 };
static void check_bluez_and_try_setup (NMBluezManager *self);
struct AsyncData {
NMBluezManager *self;
GCancellable *async_cancellable;
};
static struct AsyncData *
async_data_pack (NMBluezManager *self)
{
struct AsyncData *data = g_new (struct AsyncData, 1);
data->self = self;
data->async_cancellable = g_object_ref (NM_BLUEZ_MANAGER_GET_PRIVATE (self)->async_cancellable);
return data;
}
static NMBluezManager *
async_data_unpack (struct AsyncData *async_data)
{
NMBluezManager *self = g_cancellable_is_cancelled (async_data->async_cancellable)
? NULL : async_data->self;
g_object_unref (async_data->async_cancellable);
g_free (async_data);
return self;
}
/**
* Cancel any current attempt to detect the version and cleanup
* the related fields.
**/
static void
cleanup_checking (NMBluezManager *self, gboolean do_unwatch_name)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
if (priv->async_cancellable) {
g_cancellable_cancel (priv->async_cancellable);
g_clear_object (&priv->async_cancellable);
}
g_clear_object (&priv->introspect_proxy);
if (do_unwatch_name && priv->watch_name_id) {
g_bus_unwatch_name (priv->watch_name_id);
priv->watch_name_id = 0;
}
}
static void
manager_bdaddr_added_cb (NMBluez4Manager *bluez_mgr,
NMBluezDevice *bt_device,
const char *bdaddr,
const char *name,
const char *object_path,
guint32 uuids,
gpointer user_data)
{
/* forward the signal... */
g_signal_emit (NM_BLUEZ_MANAGER (user_data), signals[BDADDR_ADDED], 0,
bt_device,
bdaddr,
name,
object_path,
uuids);
}
static void
manager_bdaddr_removed_cb (NMBluez4Manager *bluez_mgr,
const char *bdaddr,
const char *object_path,
gpointer user_data)
{
/* forward the signal... */
g_signal_emit (NM_BLUEZ_MANAGER (user_data), signals[BDADDR_REMOVED], 0,
bdaddr,
object_path);
}
static void
setup_version_number (NMBluezManager *self, int bluez_version)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
g_return_if_fail (!priv->bluez_version);
nm_log_info (LOGD_BT, "use BlueZ version %d", bluez_version);
priv->bluez_version = bluez_version;
/* Just detected the version. Cleanup the ongoing checking/detection. */
cleanup_checking (self, TRUE);
}
static void
setup_bluez4 (NMBluezManager *self)
{
NMBluez4Manager *manager;
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
g_return_if_fail (!priv->manager4 && !priv->manager5 && !priv->bluez_version);
setup_version_number (self, 4);
priv->manager4 = manager = nm_bluez4_manager_new (priv->provider);
g_signal_connect (manager,
NM_BLUEZ_MANAGER_BDADDR_ADDED,
G_CALLBACK (manager_bdaddr_added_cb),
self);
g_signal_connect (manager,
NM_BLUEZ_MANAGER_BDADDR_REMOVED,
G_CALLBACK (manager_bdaddr_removed_cb),
self);
nm_bluez4_manager_query_devices (manager);
}
static void
setup_bluez5 (NMBluezManager *self)
{
NMBluez5Manager *manager;
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
g_return_if_fail (!priv->manager4 && !priv->manager5 && !priv->bluez_version);
setup_version_number (self, 5);
priv->manager5 = manager = nm_bluez5_manager_new (priv->provider);
g_signal_connect (manager,
NM_BLUEZ_MANAGER_BDADDR_ADDED,
G_CALLBACK (manager_bdaddr_added_cb),
self);
g_signal_connect (manager,
NM_BLUEZ_MANAGER_BDADDR_REMOVED,
G_CALLBACK (manager_bdaddr_removed_cb),
self);
nm_bluez5_manager_query_devices (manager);
}
static void
watch_name_on_appeared (GDBusConnection *connection,
const gchar *name,
const gchar *name_owner,
gpointer user_data)
{
check_bluez_and_try_setup (NM_BLUEZ_MANAGER (user_data));
}
static void
check_bluez_and_try_setup_final_step (NMBluezManager *self, int bluez_version, const char *reason)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
g_return_if_fail (!priv->bluez_version);
switch (bluez_version) {
case 4:
setup_bluez4 (self);
break;
case 5:
setup_bluez5 (self);
break;
default:
nm_log_dbg (LOGD_BT, "detecting BlueZ version failed: %s", reason);
/* cancel current attempts to detect the version. */
cleanup_checking (self, FALSE);
if (!priv->watch_name_id) {
priv->watch_name_id = g_bus_watch_name (G_BUS_TYPE_SYSTEM,
BLUEZ_SERVICE,
G_BUS_NAME_WATCHER_FLAGS_NONE,
watch_name_on_appeared,
NULL,
self,
NULL);
}
break;
}
}
static void
check_bluez_and_try_setup_do_introspect (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
NMBluezManager *self = async_data_unpack (user_data);
NMBluezManagerPrivate *priv;
GError *error = NULL;
GVariant *result;
const char *xml_data;
int bluez_version = 0;
const char *reason = NULL;
if (!self)
return;
priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
g_return_if_fail (priv->introspect_proxy);
g_return_if_fail (!g_cancellable_is_cancelled (priv->async_cancellable));
g_return_if_fail (!priv->bluez_version);
g_clear_object (&priv->async_cancellable);
result = g_dbus_proxy_call_finish (priv->introspect_proxy, res, &error);
if (!result) {
char *reason2 = g_strdup_printf ("introspect failed with %s", error->message);
check_bluez_and_try_setup_final_step (self, 0, reason2);
g_error_free (error);
g_free (reason2);
return;
}
g_variant_get (result, "(&s)", &xml_data);
/* might not be the best approach to detect the version, but it's good enough in practice. */
if (strstr (xml_data, "org.freedesktop.DBus.ObjectManager"))
bluez_version = 5;
else if (strstr (xml_data, BLUEZ4_MANAGER_INTERFACE))
bluez_version = 4;
else
reason = "unexpected introspect result";
g_variant_unref (result);
check_bluez_and_try_setup_final_step (self, bluez_version, reason);
}
static void
check_bluez_and_try_setup_on_new_proxy (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
NMBluezManager *self = async_data_unpack (user_data);
NMBluezManagerPrivate *priv;
GError *error = NULL;
if (!self)
return;
priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
g_return_if_fail (!priv->introspect_proxy);
g_return_if_fail (!g_cancellable_is_cancelled (priv->async_cancellable));
g_return_if_fail (!priv->bluez_version);
priv->introspect_proxy = g_dbus_proxy_new_for_bus_finish (res, &error);
if (!priv->introspect_proxy) {
char *reason = g_strdup_printf ("bluez error creating dbus proxy: %s", error->message);
check_bluez_and_try_setup_final_step (self, 0, reason);
g_error_free (error);
g_free (reason);
return;
}
g_dbus_proxy_call (priv->introspect_proxy,
"Introspect",
NULL,
G_DBUS_CALL_FLAGS_NO_AUTO_START,
3000,
priv->async_cancellable,
check_bluez_and_try_setup_do_introspect,
async_data_pack (self));
}
static void
check_bluez_and_try_setup (NMBluezManager *self)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
g_return_if_fail (!priv->bluez_version);
/* there should be no ongoing detection. Anyway, cleanup_checking. */
cleanup_checking (self, FALSE);
priv->async_cancellable = g_cancellable_new ();
g_dbus_proxy_new_for_bus (G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
NULL,
BLUEZ_SERVICE,
"/",
DBUS_INTERFACE_INTROSPECTABLE,
priv->async_cancellable,
check_bluez_and_try_setup_on_new_proxy,
async_data_pack (self));
}
void
nm_bluez_manager_query_devices (NMBluezManager *self)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
switch (priv->bluez_version) {
case 4:
nm_bluez4_manager_query_devices (priv->manager4);
break;
case 5:
nm_bluez5_manager_query_devices (priv->manager5);
break;
default:
/* the proxy implementation does nothing in this case. */
break;
}
}
NMBluezManager *
nm_bluez_manager_new (NMConnectionProvider *provider)
{
g_return_val_if_fail (NM_IS_CONNECTION_PROVIDER (provider), NULL);
return g_object_new (NM_TYPE_BLUEZ_MANAGER,
NM_BLUEZ_MANAGER_PROVIDER,
provider,
NULL);
}
static void
set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (object);
switch (prop_id) {
case PROP_PROVIDER:
/* Construct only */
priv->provider = g_value_dup_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (object);
switch (prop_id) {
case PROP_PROVIDER:
g_value_set_object (value, priv->provider);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
dispose (GObject *object)
{
NMBluezManager *self = NM_BLUEZ_MANAGER (object);
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
g_clear_object (&priv->provider);
if (priv->manager4) {
g_signal_handlers_disconnect_by_func (priv->manager4, G_CALLBACK (manager_bdaddr_added_cb), self);
g_signal_handlers_disconnect_by_func (priv->manager4, G_CALLBACK (manager_bdaddr_removed_cb), self);
g_clear_object (&priv->manager4);
}
if (priv->manager5) {
g_signal_handlers_disconnect_by_func (priv->manager5, G_CALLBACK (manager_bdaddr_added_cb), self);
g_signal_handlers_disconnect_by_func (priv->manager5, G_CALLBACK (manager_bdaddr_removed_cb), self);
g_clear_object (&priv->manager5);
}
cleanup_checking (self, TRUE);
priv->bluez_version = 0;
}
static void
constructed (GObject *object)
{
NMBluezManager *self = NM_BLUEZ_MANAGER (object);
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
G_OBJECT_CLASS (nm_bluez_manager_parent_class)->constructed (object);
g_return_if_fail (priv->provider);
check_bluez_and_try_setup (self);
}
static void
nm_bluez_manager_init (NMBluezManager *self)
{
}
static void
nm_bluez_manager_class_init (NMBluezManagerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
g_type_class_add_private (klass, sizeof (NMBluezManagerPrivate));
/* virtual methods */
object_class->dispose = dispose;
object_class->get_property = get_property;
object_class->set_property = set_property;
object_class->constructed = constructed;
g_object_class_install_property
(object_class, PROP_PROVIDER,
g_param_spec_object (NM_BLUEZ_MANAGER_PROVIDER,
"Provider",
"Connection Provider",
NM_TYPE_CONNECTION_PROVIDER,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
/* Signals */
signals[BDADDR_ADDED] =
g_signal_new (NM_BLUEZ_MANAGER_BDADDR_ADDED,
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMBluezManagerClass, bdaddr_added),
NULL, NULL, NULL,
G_TYPE_NONE, 5, G_TYPE_OBJECT, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT);
signals[BDADDR_REMOVED] =
g_signal_new (NM_BLUEZ_MANAGER_BDADDR_REMOVED,
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMBluezManagerClass, bdaddr_removed),
NULL, NULL, NULL,
G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);
}

71
src/bluez-manager/nm-bluez-manager.h Normal file
View file

@ -0,0 +1,71 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/* NetworkManager -- Network link manager
*
* 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.
*
* Copyright (C) 2007 - 2008 Novell, Inc.
* Copyright (C) 2007 - 2013 Red Hat, Inc.
*/
#ifndef NM_BLUEZ_MANAGER_H
#define NM_BLUEZ_MANAGER_H
#include <glib.h>
#include <glib-object.h>
#include <config.h>
#include "nm-connection-provider.h"
G_BEGIN_DECLS
#define NM_TYPE_BLUEZ_MANAGER (nm_bluez_manager_get_type ())
#define NM_BLUEZ_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NM_TYPE_BLUEZ_MANAGER, NMBluezManager))
#define NM_BLUEZ_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), NM_TYPE_BLUEZ_MANAGER, NMBluezManagerClass))
#define NM_IS_BLUEZ_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), NM_TYPE_BLUEZ_MANAGER))
#define NM_IS_BLUEZ_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), NM_TYPE_BLUEZ_MANAGER))
#define NM_BLUEZ_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), NM_TYPE_BLUEZ_MANAGER, NMBluezManagerClass))
#define NM_BLUEZ_MANAGER_BDADDR_ADDED "bdaddr-added"
#define NM_BLUEZ_MANAGER_BDADDR_REMOVED "bdaddr-removed"
#define NM_BLUEZ_MANAGER_PROVIDER "provider"
typedef struct {
GObject parent;
} NMBluezManager;
typedef struct {
GObjectClass parent;
/* Virtual functions */
void (*bdaddr_added) (NMBluezManager *manager,
const char *bdaddr,
const char *name,
const char *object_path,
guint uuids);
void (*bdaddr_removed) (NMBluezManager *manager,
const char *bdaddr,
const char *object_path);
} NMBluezManagerClass;
GType nm_bluez_manager_get_type (void);
NMBluezManager *nm_bluez_manager_new (NMConnectionProvider *provider);
void nm_bluez_manager_query_devices (NMBluezManager *manager);
#endif /* NM_BLUEZ_MANAGER_H */

90
src/bluez-manager/nm-bluez4-manager.c
View file

@ -16,7 +16,7 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Copyright (C) 2007 - 2008 Novell, Inc.
* Copyright (C) 2007 - 2012 Red Hat, Inc.
* Copyright (C) 2007 - 2013 Red Hat, Inc.
*/
#include <signal.h>
@ -26,6 +26,7 @@
#include "nm-logging.h"
#include "nm-dbus-glib-types.h"
#include "nm-bluez-manager.h"
#include "nm-bluez4-manager.h"
#include "nm-bluez4-adapter.h"
#include "nm-dbus-manager.h"
@ -41,11 +42,11 @@ typedef struct {
DBusGProxy *proxy;
NMBluez4Adapter *adapter;
} NMBluezManagerPrivate;
} NMBluez4ManagerPrivate;
#define NM_BLUEZ_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_BLUEZ_MANAGER, NMBluezManagerPrivate))
#define NM_BLUEZ4_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_BLUEZ4_MANAGER, NMBluez4ManagerPrivate))
G_DEFINE_TYPE (NMBluezManager, nm_bluez_manager, G_TYPE_OBJECT)
G_DEFINE_TYPE (NMBluez4Manager, nm_bluez4_manager, G_TYPE_OBJECT)
enum {
BDADDR_ADDED,
@ -58,7 +59,7 @@ static guint signals[LAST_SIGNAL] = { 0 };
static void
emit_bdaddr_added (NMBluezManager *self, NMBluezDevice *device)
emit_bdaddr_added (NMBluez4Manager *self, NMBluezDevice *device)
{
g_signal_emit (self, signals[BDADDR_ADDED], 0,
device,
@ -69,9 +70,9 @@ emit_bdaddr_added (NMBluezManager *self, NMBluezDevice *device)
}
void
nm_bluez_manager_query_devices (NMBluezManager *self)
nm_bluez4_manager_query_devices (NMBluez4Manager *self)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez4ManagerPrivate *priv = NM_BLUEZ4_MANAGER_GET_PRIVATE (self);
GSList *devices, *iter;
if (!priv->adapter)
@ -86,13 +87,13 @@ nm_bluez_manager_query_devices (NMBluezManager *self)
static void
device_added (NMBluez4Adapter *adapter, NMBluezDevice *device, gpointer user_data)
{
emit_bdaddr_added (NM_BLUEZ_MANAGER (user_data), device);
emit_bdaddr_added (NM_BLUEZ4_MANAGER (user_data), device);
}
static void
device_removed (NMBluez4Adapter *adapter, NMBluezDevice *device, gpointer user_data)
{
NMBluezManager *self = NM_BLUEZ_MANAGER (user_data);
NMBluez4Manager *self = NM_BLUEZ4_MANAGER (user_data);
g_signal_emit (self, signals[BDADDR_REMOVED], 0,
nm_bluez_device_get_address (device),
@ -102,8 +103,8 @@ device_removed (NMBluez4Adapter *adapter, NMBluezDevice *device, gpointer user_d
static void
adapter_initialized (NMBluez4Adapter *adapter, gboolean success, gpointer user_data)
{
NMBluezManager *self = NM_BLUEZ_MANAGER (user_data);
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez4Manager *self = NM_BLUEZ4_MANAGER (user_data);
NMBluez4ManagerPrivate *priv = NM_BLUEZ4_MANAGER_GET_PRIVATE (self);
if (success) {
GSList *devices, *iter;
@ -122,9 +123,9 @@ adapter_initialized (NMBluez4Adapter *adapter, gboolean success, gpointer user_d
}
static void
adapter_removed (DBusGProxy *proxy, const char *path, NMBluezManager *self)
adapter_removed (DBusGProxy *proxy, const char *path, NMBluez4Manager *self)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez4ManagerPrivate *priv = NM_BLUEZ4_MANAGER_GET_PRIVATE (self);
if (priv->adapter && !strcmp (path, nm_bluez4_adapter_get_path (priv->adapter))) {
if (nm_bluez4_adapter_get_initialized (priv->adapter)) {
@ -147,9 +148,9 @@ adapter_removed (DBusGProxy *proxy, const char *path, NMBluezManager *self)
}
static void
default_adapter_changed (DBusGProxy *proxy, const char *path, NMBluezManager *self)
default_adapter_changed (DBusGProxy *proxy, const char *path, NMBluez4Manager *self)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez4ManagerPrivate *priv = NM_BLUEZ4_MANAGER_GET_PRIVATE (self);
const char *cur_path = NULL;
if (priv->adapter)
@ -175,8 +176,8 @@ default_adapter_changed (DBusGProxy *proxy, const char *path, NMBluezManager *se
static void
default_adapter_cb (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data)
{
NMBluezManager *self = NM_BLUEZ_MANAGER (user_data);
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez4Manager *self = NM_BLUEZ4_MANAGER (user_data);
NMBluez4ManagerPrivate *priv = NM_BLUEZ4_MANAGER_GET_PRIVATE (self);
const char *default_adapter = NULL;
GError *err = NULL;
@ -198,9 +199,9 @@ default_adapter_cb (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data)
}
static void
query_default_adapter (NMBluezManager *self)
query_default_adapter (NMBluez4Manager *self)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez4ManagerPrivate *priv = NM_BLUEZ4_MANAGER_GET_PRIVATE (self);
DBusGProxyCall *call;
call = dbus_g_proxy_begin_call (priv->proxy, "DefaultAdapter",
@ -212,9 +213,9 @@ query_default_adapter (NMBluezManager *self)
}
static void
bluez_connect (NMBluezManager *self)
bluez_connect (NMBluez4Manager *self)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez4ManagerPrivate *priv = NM_BLUEZ4_MANAGER_GET_PRIVATE (self);
DBusGConnection *connection;
g_return_if_fail (priv->proxy == NULL);
@ -248,8 +249,8 @@ name_owner_changed_cb (NMDBusManager *dbus_mgr,
const char *new_owner,
gpointer user_data)
{
NMBluezManager *self = NM_BLUEZ_MANAGER (user_data);
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez4Manager *self = NM_BLUEZ4_MANAGER (user_data);
NMBluez4ManagerPrivate *priv = NM_BLUEZ4_MANAGER_GET_PRIVATE (self);
gboolean old_owner_good = (old_owner && strlen (old_owner));
gboolean new_owner_good = (new_owner && strlen (new_owner));
@ -269,9 +270,9 @@ name_owner_changed_cb (NMDBusManager *dbus_mgr,
}
static void
bluez_cleanup (NMBluezManager *self, gboolean do_signal)
bluez_cleanup (NMBluez4Manager *self, gboolean do_signal)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez4ManagerPrivate *priv = NM_BLUEZ4_MANAGER_GET_PRIVATE (self);
if (priv->proxy) {
g_object_unref (priv->proxy);
@ -289,7 +290,7 @@ dbus_connection_changed_cb (NMDBusManager *dbus_mgr,
DBusGConnection *connection,
gpointer user_data)
{
NMBluezManager *self = NM_BLUEZ_MANAGER (user_data);
NMBluez4Manager *self = NM_BLUEZ4_MANAGER (user_data);
if (!connection)
bluez_cleanup (self, TRUE);
@ -299,27 +300,20 @@ dbus_connection_changed_cb (NMDBusManager *dbus_mgr,
/****************************************************************/
NMBluezManager *
nm_bluez_manager_get (NMConnectionProvider *provider)
NMBluez4Manager *
nm_bluez4_manager_new (NMConnectionProvider *provider)
{
static NMBluezManager *singleton = NULL;
NMBluez4Manager *instance;
if (singleton)
return g_object_ref (singleton);
singleton = (NMBluezManager *) g_object_new (NM_TYPE_BLUEZ_MANAGER, NULL);
g_assert (singleton);
/* Cache the connection provider for NMBluez4Adapter objects */
NM_BLUEZ_MANAGER_GET_PRIVATE (singleton)->provider = provider;
return singleton;
instance = g_object_new (NM_TYPE_BLUEZ4_MANAGER, NULL);
NM_BLUEZ4_MANAGER_GET_PRIVATE (instance)->provider = provider;
return instance;
}
static void
nm_bluez_manager_init (NMBluezManager *self)
nm_bluez4_manager_init (NMBluez4Manager *self)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez4ManagerPrivate *priv = NM_BLUEZ4_MANAGER_GET_PRIVATE (self);
priv->dbus_mgr = nm_dbus_manager_get ();
g_assert (priv->dbus_mgr);
@ -340,8 +334,8 @@ nm_bluez_manager_init (NMBluezManager *self)
static void
dispose (GObject *object)
{
NMBluezManager *self = NM_BLUEZ_MANAGER (object);
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez4Manager *self = NM_BLUEZ4_MANAGER (object);
NMBluez4ManagerPrivate *priv = NM_BLUEZ4_MANAGER_GET_PRIVATE (self);
bluez_cleanup (self, FALSE);
@ -351,15 +345,15 @@ dispose (GObject *object)
priv->dbus_mgr = NULL;
}
G_OBJECT_CLASS (nm_bluez_manager_parent_class)->dispose (object);
G_OBJECT_CLASS (nm_bluez4_manager_parent_class)->dispose (object);
}
static void
nm_bluez_manager_class_init (NMBluezManagerClass *klass)
nm_bluez4_manager_class_init (NMBluez4ManagerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
g_type_class_add_private (klass, sizeof (NMBluezManagerPrivate));
g_type_class_add_private (klass, sizeof (NMBluez4ManagerPrivate));
/* virtual methods */
object_class->dispose = dispose;
@ -369,7 +363,7 @@ nm_bluez_manager_class_init (NMBluezManagerClass *klass)
g_signal_new (NM_BLUEZ_MANAGER_BDADDR_ADDED,
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMBluezManagerClass, bdaddr_added),
G_STRUCT_OFFSET (NMBluez4ManagerClass, bdaddr_added),
NULL, NULL, NULL,
G_TYPE_NONE, 5, G_TYPE_OBJECT, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT);
@ -378,7 +372,7 @@ nm_bluez_manager_class_init (NMBluezManagerClass *klass)
g_signal_new (NM_BLUEZ_MANAGER_BDADDR_REMOVED,
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMBluezManagerClass, bdaddr_removed),
G_STRUCT_OFFSET (NMBluez4ManagerClass, bdaddr_removed),
NULL, NULL, NULL,
G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);
}

37
src/bluez-manager/nm-bluez4-manager.h
View file

@ -16,11 +16,11 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Copyright (C) 2007 - 2008 Novell, Inc.
* Copyright (C) 2007 - 2012 Red Hat, Inc.
* Copyright (C) 2007 - 2013 Red Hat, Inc.
*/
#ifndef NM_BLUEZ_MANAGER_H
#define NM_BLUEZ_MANAGER_H
#ifndef NM_BLUEZ4_MANAGER_H
#define NM_BLUEZ4_MANAGER_H
#include <glib.h>
#include <glib-object.h>
@ -30,40 +30,37 @@
G_BEGIN_DECLS
#define NM_TYPE_BLUEZ_MANAGER (nm_bluez_manager_get_type ())
#define NM_BLUEZ_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NM_TYPE_BLUEZ_MANAGER, NMBluezManager))
#define NM_BLUEZ_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), NM_TYPE_BLUEZ_MANAGER, NMBluezManagerClass))
#define NM_IS_BLUEZ_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), NM_TYPE_BLUEZ_MANAGER))
#define NM_IS_BLUEZ_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), NM_TYPE_BLUEZ_MANAGER))
#define NM_BLUEZ_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), NM_TYPE_BLUEZ_MANAGER, NMBluezManagerClass))
#define NM_BLUEZ_MANAGER_BDADDR_ADDED "bdaddr-added"
#define NM_BLUEZ_MANAGER_BDADDR_REMOVED "bdaddr-removed"
#define NM_TYPE_BLUEZ4_MANAGER (nm_bluez4_manager_get_type ())
#define NM_BLUEZ4_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NM_TYPE_BLUEZ4_MANAGER, NMBluez4Manager))
#define NM_BLUEZ4_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), NM_TYPE_BLUEZ4_MANAGER, NMBluez4ManagerClass))
#define NM_IS_BLUEZ4_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), NM_TYPE_BLUEZ4_MANAGER))
#define NM_IS_BLUEZ4_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), NM_TYPE_BLUEZ4_MANAGER))
#define NM_BLUEZ4_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), NM_TYPE_BLUEZ4_MANAGER, NMBluez4ManagerClass))
typedef struct {
GObject parent;
} NMBluezManager;
} NMBluez4Manager;
typedef struct {
GObjectClass parent;
/* Virtual functions */
void (*bdaddr_added) (NMBluezManager *manager,
void (*bdaddr_added) (NMBluez4Manager *manager,
const char *bdaddr,
const char *name,
const char *object_path,
guint uuids);
void (*bdaddr_removed) (NMBluezManager *manager,
void (*bdaddr_removed) (NMBluez4Manager *manager,
const char *bdaddr,
const char *object_path);
} NMBluezManagerClass;
} NMBluez4ManagerClass;
GType nm_bluez_manager_get_type (void);
GType nm_bluez4_manager_get_type (void);
NMBluezManager *nm_bluez_manager_get (NMConnectionProvider *provider);
NMBluez4Manager *nm_bluez4_manager_new (NMConnectionProvider *provider);
void nm_bluez_manager_query_devices (NMBluezManager *manager);
void nm_bluez4_manager_query_devices (NMBluez4Manager *manager);
#endif /* NM_BLUEZ_MANAGER_H */
#endif /* NM_BLUEZ4_MANAGER_H */

104
src/bluez-manager/nm-bluez5-manager.c
View file

@ -16,7 +16,7 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Copyright (C) 2007 - 2008 Novell, Inc.
* Copyright (C) 2007 - 2012 Red Hat, Inc.
* Copyright (C) 2007 - 2013 Red Hat, Inc.
* Copyright (C) 2013 Intel Corporation.
*/
@ -26,6 +26,7 @@
#include <gio/gio.h>
#include "nm-logging.h"
#include "nm-bluez-manager.h"
#include "nm-bluez5-manager.h"
#include "nm-bluez-device.h"
#include "nm-bluez-common.h"
@ -41,11 +42,11 @@ typedef struct {
GDBusProxy *proxy;
GHashTable *devices;
} NMBluezManagerPrivate;
} NMBluez5ManagerPrivate;
#define NM_BLUEZ_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_BLUEZ_MANAGER, NMBluezManagerPrivate))
#define NM_BLUEZ5_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_BLUEZ5_MANAGER, NMBluez5ManagerPrivate))
G_DEFINE_TYPE (NMBluezManager, nm_bluez_manager, G_TYPE_OBJECT)
G_DEFINE_TYPE (NMBluez5Manager, nm_bluez5_manager, G_TYPE_OBJECT)
enum {
BDADDR_ADDED,
@ -56,11 +57,11 @@ enum {
static guint signals[LAST_SIGNAL] = { 0 };
static void device_initialized (NMBluezDevice *device, gboolean success, NMBluezManager *self);
static void device_usable (NMBluezDevice *device, GParamSpec *pspec, NMBluezManager *self);
static void device_initialized (NMBluezDevice *device, gboolean success, NMBluez5Manager *self);
static void device_usable (NMBluezDevice *device, GParamSpec *pspec, NMBluez5Manager *self);
static void
emit_bdaddr_added (NMBluezManager *self, NMBluezDevice *device)
emit_bdaddr_added (NMBluez5Manager *self, NMBluezDevice *device)
{
g_signal_emit (self, signals[BDADDR_ADDED], 0,
device,
@ -71,9 +72,9 @@ emit_bdaddr_added (NMBluezManager *self, NMBluezDevice *device)
}
void
nm_bluez_manager_query_devices (NMBluezManager *self)
nm_bluez5_manager_query_devices (NMBluez5Manager *self)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez5ManagerPrivate *priv = NM_BLUEZ5_MANAGER_GET_PRIVATE (self);
NMBluezDevice *device;
GHashTableIter iter;
@ -85,7 +86,7 @@ nm_bluez_manager_query_devices (NMBluezManager *self)
}
static void
remove_device (NMBluezManager *self, NMBluezDevice *device)
remove_device (NMBluez5Manager *self, NMBluezDevice *device)
{
if (nm_bluez_device_get_usable (device)) {
g_signal_emit (self, signals[BDADDR_REMOVED], 0,
@ -97,11 +98,11 @@ remove_device (NMBluezManager *self, NMBluezDevice *device)
}
static void
remove_all_devices (NMBluezManager *self)
remove_all_devices (NMBluez5Manager *self)
{
GHashTableIter iter;
NMBluezDevice *device;
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez5ManagerPrivate *priv = NM_BLUEZ5_MANAGER_GET_PRIVATE (self);
g_hash_table_iter_init (&iter, priv->devices);
while (g_hash_table_iter_next (&iter, NULL, (gpointer) &device)) {
@ -112,7 +113,7 @@ remove_all_devices (NMBluezManager *self)
}
static void
device_usable (NMBluezDevice *device, GParamSpec *pspec, NMBluezManager *self)
device_usable (NMBluezDevice *device, GParamSpec *pspec, NMBluez5Manager *self)
{
gboolean usable = nm_bluez_device_get_usable (device);
@ -132,9 +133,9 @@ device_usable (NMBluezDevice *device, GParamSpec *pspec, NMBluezManager *self)
}
static void
device_initialized (NMBluezDevice *device, gboolean success, NMBluezManager *self)
device_initialized (NMBluezDevice *device, gboolean success, NMBluez5Manager *self)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez5ManagerPrivate *priv = NM_BLUEZ5_MANAGER_GET_PRIVATE (self);
nm_log_dbg (LOGD_BT, "(%s): bluez device %s",
nm_bluez_device_get_path (device),
@ -144,9 +145,9 @@ device_initialized (NMBluezDevice *device, gboolean success, NMBluezManager *sel
}
static void
device_added (GDBusProxy *proxy, const gchar *path, NMBluezManager *self)
device_added (GDBusProxy *proxy, const gchar *path, NMBluez5Manager *self)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez5ManagerPrivate *priv = NM_BLUEZ5_MANAGER_GET_PRIVATE (self);
NMBluezDevice *device;
device = nm_bluez_device_new (path, priv->provider, 5);
@ -158,9 +159,9 @@ device_added (GDBusProxy *proxy, const gchar *path, NMBluezManager *self)
}
static void
device_removed (GDBusProxy *proxy, const gchar *path, NMBluezManager *self)
device_removed (GDBusProxy *proxy, const gchar *path, NMBluez5Manager *self)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez5ManagerPrivate *priv = NM_BLUEZ5_MANAGER_GET_PRIVATE (self);
NMBluezDevice *device;
nm_log_dbg (LOGD_BT, "(%s): bluez device removed", path);
@ -168,7 +169,7 @@ device_removed (GDBusProxy *proxy, const gchar *path, NMBluezManager *self)
device = g_hash_table_lookup (priv->devices, path);
if (device) {
g_hash_table_steal (priv->devices, nm_bluez_device_get_path (device));
remove_device (NM_BLUEZ_MANAGER (self), device);
remove_device (NM_BLUEZ5_MANAGER (self), device);
g_object_unref (device);
}
}
@ -178,7 +179,7 @@ object_manager_g_signal (GDBusProxy *proxy,
gchar *sender_name,
gchar *signal_name,
GVariant *parameters,
NMBluezManager *self)
NMBluez5Manager *self)
{
GVariant *variant;
const gchar *path;
@ -212,7 +213,7 @@ object_manager_g_signal (GDBusProxy *proxy,
static void
get_managed_objects_cb (GDBusProxy *proxy,
GAsyncResult *res,
NMBluezManager *self)
NMBluez5Manager *self)
{
GVariant *variant, *ifaces;
GVariantIter i;
@ -245,9 +246,9 @@ get_managed_objects_cb (GDBusProxy *proxy,
static void
on_proxy_acquired (GObject *object,
GAsyncResult *res,
NMBluezManager *self)
NMBluez5Manager *self)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez5ManagerPrivate *priv = NM_BLUEZ5_MANAGER_GET_PRIVATE (self);
GError *error = NULL;
priv->proxy = g_dbus_proxy_new_for_bus_finish (res, &error);
@ -273,9 +274,9 @@ on_proxy_acquired (GObject *object,
}
static void
bluez_connect (NMBluezManager *self)
bluez_connect (NMBluez5Manager *self)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez5ManagerPrivate *priv = NM_BLUEZ5_MANAGER_GET_PRIVATE (self);
g_return_if_fail (priv->proxy == NULL);
@ -297,8 +298,8 @@ name_owner_changed_cb (NMDBusManager *dbus_mgr,
const char *new_owner,
gpointer user_data)
{
NMBluezManager *self = NM_BLUEZ_MANAGER (user_data);
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez5Manager *self = NM_BLUEZ5_MANAGER (user_data);
NMBluez5ManagerPrivate *priv = NM_BLUEZ5_MANAGER_GET_PRIVATE (self);
gboolean old_owner_good = (old_owner && strlen (old_owner));
gboolean new_owner_good = (new_owner && strlen (new_owner));
@ -313,9 +314,9 @@ name_owner_changed_cb (NMDBusManager *dbus_mgr,
}
static void
bluez_cleanup (NMBluezManager *self, gboolean do_signal)
bluez_cleanup (NMBluez5Manager *self, gboolean do_signal)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez5ManagerPrivate *priv = NM_BLUEZ5_MANAGER_GET_PRIVATE (self);
if (priv->proxy) {
g_object_unref (priv->proxy);
@ -333,7 +334,7 @@ dbus_connection_changed_cb (NMDBusManager *dbus_mgr,
DBusGConnection *connection,
gpointer user_data)
{
NMBluezManager *self = NM_BLUEZ_MANAGER (user_data);
NMBluez5Manager *self = NM_BLUEZ5_MANAGER (user_data);
if (!connection)
bluez_cleanup (self, TRUE);
@ -343,27 +344,20 @@ dbus_connection_changed_cb (NMDBusManager *dbus_mgr,
/****************************************************************/
NMBluezManager *
nm_bluez_manager_get (NMConnectionProvider *provider)
NMBluez5Manager *
nm_bluez5_manager_new (NMConnectionProvider *provider)
{
static NMBluezManager *singleton = NULL;
NMBluez5Manager *instance = NULL;
if (singleton)
return g_object_ref (singleton);
singleton = (NMBluezManager *) g_object_new (NM_TYPE_BLUEZ_MANAGER, NULL);
g_assert (singleton);
/* Cache the connection provider */
NM_BLUEZ_MANAGER_GET_PRIVATE (singleton)->provider = provider;
return singleton;
instance = g_object_new (NM_TYPE_BLUEZ5_MANAGER, NULL);
NM_BLUEZ5_MANAGER_GET_PRIVATE (instance)->provider = provider;
return instance;
}
static void
nm_bluez_manager_init (NMBluezManager *self)
nm_bluez5_manager_init (NMBluez5Manager *self)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez5ManagerPrivate *priv = NM_BLUEZ5_MANAGER_GET_PRIVATE (self);
priv->dbus_mgr = nm_dbus_manager_get ();
g_assert (priv->dbus_mgr);
@ -387,8 +381,8 @@ nm_bluez_manager_init (NMBluezManager *self)
static void
dispose (GObject *object)
{
NMBluezManager *self = NM_BLUEZ_MANAGER (object);
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self);
NMBluez5Manager *self = NM_BLUEZ5_MANAGER (object);
NMBluez5ManagerPrivate *priv = NM_BLUEZ5_MANAGER_GET_PRIVATE (self);
bluez_cleanup (self, FALSE);
@ -398,25 +392,25 @@ dispose (GObject *object)
priv->dbus_mgr = NULL;
}
G_OBJECT_CLASS (nm_bluez_manager_parent_class)->dispose (object);
G_OBJECT_CLASS (nm_bluez5_manager_parent_class)->dispose (object);
}
static void
finalize (GObject *object)
{
NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (object);
NMBluez5ManagerPrivate *priv = NM_BLUEZ5_MANAGER_GET_PRIVATE (object);
g_hash_table_destroy (priv->devices);
G_OBJECT_CLASS (nm_bluez_manager_parent_class)->finalize (object);
G_OBJECT_CLASS (nm_bluez5_manager_parent_class)->finalize (object);
}
static void
nm_bluez_manager_class_init (NMBluezManagerClass *klass)
nm_bluez5_manager_class_init (NMBluez5ManagerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
g_type_class_add_private (klass, sizeof (NMBluezManagerPrivate));
g_type_class_add_private (klass, sizeof (NMBluez5ManagerPrivate));
/* virtual methods */
object_class->dispose = dispose;
@ -427,7 +421,7 @@ nm_bluez_manager_class_init (NMBluezManagerClass *klass)
g_signal_new (NM_BLUEZ_MANAGER_BDADDR_ADDED,
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMBluezManagerClass, bdaddr_added),
G_STRUCT_OFFSET (NMBluez5ManagerClass, bdaddr_added),
NULL, NULL, NULL,
G_TYPE_NONE, 5, G_TYPE_OBJECT, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT);
@ -436,7 +430,7 @@ nm_bluez_manager_class_init (NMBluezManagerClass *klass)
g_signal_new (NM_BLUEZ_MANAGER_BDADDR_REMOVED,
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMBluezManagerClass, bdaddr_removed),
G_STRUCT_OFFSET (NMBluez5ManagerClass, bdaddr_removed),
NULL, NULL, NULL,
G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);
}

39
src/bluez-manager/nm-bluez5-manager.h
View file

@ -1,4 +1,4 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/* -*- Mode: C; tab-width: 5; indent-tabs-mode: t; c-basic-offset: 5 -*- */
/* NetworkManager -- Network link manager
*
* This program is free software; you can redistribute it and/or modify
@ -16,11 +16,11 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Copyright (C) 2007 - 2008 Novell, Inc.
* Copyright (C) 2007 - 2012 Red Hat, Inc.
* Copyright (C) 2007 - 2013 Red Hat, Inc.
*/
#ifndef NM_BLUEZ_MANAGER_H
#define NM_BLUEZ_MANAGER_H
#ifndef NM_BLUEZ5_MANAGER_H
#define NM_BLUEZ5_MANAGER_H
#include <glib.h>
#include <glib-object.h>
@ -30,40 +30,37 @@
G_BEGIN_DECLS
#define NM_TYPE_BLUEZ_MANAGER (nm_bluez_manager_get_type ())
#define NM_BLUEZ_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NM_TYPE_BLUEZ_MANAGER, NMBluezManager))
#define NM_BLUEZ_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), NM_TYPE_BLUEZ_MANAGER, NMBluezManagerClass))
#define NM_IS_BLUEZ_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), NM_TYPE_BLUEZ_MANAGER))
#define NM_IS_BLUEZ_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), NM_TYPE_BLUEZ_MANAGER))
#define NM_BLUEZ_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), NM_TYPE_BLUEZ_MANAGER, NMBluezManagerClass))
#define NM_BLUEZ_MANAGER_BDADDR_ADDED "bdaddr-added"
#define NM_BLUEZ_MANAGER_BDADDR_REMOVED "bdaddr-removed"
#define NM_TYPE_BLUEZ5_MANAGER (nm_bluez5_manager_get_type ())
#define NM_BLUEZ5_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NM_TYPE_BLUEZ5_MANAGER, NMBluez5Manager))
#define NM_BLUEZ5_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), NM_TYPE_BLUEZ5_MANAGER, NMBluez5ManagerClass))
#define NM_IS_BLUEZ5_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), NM_TYPE_BLUEZ5_MANAGER))
#define NM_IS_BLUEZ5_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), NM_TYPE_BLUEZ5_MANAGER))
#define NM_BLUEZ5_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), NM_TYPE_BLUEZ5_MANAGER, NMBluez5ManagerClass))
typedef struct {
GObject parent;
} NMBluezManager;
} NMBluez5Manager;
typedef struct {
GObjectClass parent;
/* Virtual functions */
void (*bdaddr_added) (NMBluezManager *manager,
void (*bdaddr_added) (NMBluez5Manager *manager,
const char *bdaddr,
const char *name,
const char *object_path,
guint uuids);
void (*bdaddr_removed) (NMBluezManager *manager,
void (*bdaddr_removed) (NMBluez5Manager *manager,
const char *bdaddr,
const char *object_path);
} NMBluezManagerClass;
} NMBluez5ManagerClass;
GType nm_bluez_manager_get_type (void);
GType nm_bluez5_manager_get_type (void);
NMBluezManager *nm_bluez_manager_get (NMConnectionProvider *provider);
NMBluez5Manager *nm_bluez5_manager_new (NMConnectionProvider *provider);
void nm_bluez_manager_query_devices (NMBluezManager *manager);
void nm_bluez5_manager_query_devices (NMBluez5Manager *manager);
#endif /* NM_BLUEZ_MANAGER_H */
#endif /* NM_BLUEZ5_MANAGER_H */

8
src/nm-manager.c
View file

@ -67,11 +67,7 @@
#include "nm-atm-manager.h"
#include "nm-rfkill-manager.h"
#include "nm-hostname-provider.h"
#if WITH_BLUEZ4
#include "nm-bluez4-manager.h"
#else
#include "nm-bluez5-manager.h"
#endif
#include "nm-bluez-manager.h"
#include "nm-bluez-common.h"
#include "nm-settings.h"
#include "nm-settings-connection.h"
@ -4462,7 +4458,7 @@ nm_manager_new (NMSettings *settings,
G_CALLBACK (rfkill_manager_rfkill_changed_cb),
singleton);
priv->bluez_mgr = nm_bluez_manager_get (NM_CONNECTION_PROVIDER (priv->settings));
priv->bluez_mgr = nm_bluez_manager_new (NM_CONNECTION_PROVIDER (priv->settings));
g_signal_connect (priv->bluez_mgr,
NM_BLUEZ_MANAGER_BDADDR_ADDED,