2007-10-05 Dan Williams <dcbw@redhat.com>

* libnm-glib/nm-device-802-11-wireless.c
		- Cache properties and update cached properties on D-Bus signals from NM



git-svn-id: http://svn-archive.gnome.org/svn/NetworkManager/trunk@2937 4912f4e0-d625-0410-9fb7-b9a5a253dbdc

ChangeLog

@@ -1,3 +1,8 @@
+2007-10-05  Dan Williams  <dcbw@redhat.com>
+
+	* libnm-glib/nm-device-802-11-wireless.c
+		- Cache properties and update cached properties on D-Bus signals from NM
+
 2007-10-05  Dan Williams  <dcbw@redhat.com>
 
 	* src/nm-device-802-11-wireless.c

libnm-glib/nm-device-802-11-wireless.c

@@ -1,3 +1,5 @@
+#include <iwlib.h>
+
 #include "nm-device-802-11-wireless.h"
 #include "nm-device-private.h"
 
@@ -12,9 +14,38 @@ typedef struct {
 	gboolean have_ap_list;
 	GHashTable *aps;
 
+	char * hw_address;
+	int mode;
+	int rate;
+	NMAccessPoint *current_ap;
+	guint32 wireless_caps;
+
 	gboolean disposed;
 } NMDevice80211WirelessPrivate;
 
+enum {
+	PROP_0,
+	PROP_HW_ADDRESS,
+	PROP_MODE,
+	PROP_BITRATE,
+	PROP_ACTIVE_ACCESS_POINT,
+	PROP_WIRELESS_CAPABILITIES,
+
+	LAST_PROP
+};
+
+#define NM_DEVICE_802_11_WIRELESS_PROP_HW_ADDRESS "hw-address"
+#define NM_DEVICE_802_11_WIRELESS_PROP_MODE "mode"
+#define NM_DEVICE_802_11_WIRELESS_PROP_BITRATE "bitrate"
+#define NM_DEVICE_802_11_WIRELESS_PROP_ACTIVE_ACCESS_POINT "active-access-point"
+#define NM_DEVICE_802_11_WIRELESS_PROP_WIRELESS_CAPABILITIES "wireless-capabilities"
+
+#define DBUS_PROP_HW_ADDRESS "HwAddress"
+#define DBUS_PROP_MODE "Mode"
+#define DBUS_PROP_BITRATE "Bitrate"
+#define DBUS_PROP_ACTIVE_ACCESS_POINT "ActiveAccessPoint"
+#define DBUS_PROP_WIRELESS_CAPABILITIES "WirelessCapabilities"
+
 enum {
 	ACCESS_POINT_ADDED,
 	ACCESS_POINT_REMOVED,
@@ -26,6 +57,13 @@ static guint signals[LAST_SIGNAL] = { 0 };
 
 static void access_point_added_proxy (DBusGProxy *proxy, char *path, gpointer user_data);
 static void access_point_removed_proxy (DBusGProxy *proxy, char *path, gpointer user_data);
+static void properties_changed_proxy (DBusGProxy *proxy,
+                                      GHashTable *properties,
+                                      gpointer user_data);
+
+static NMAccessPoint *get_access_point (NMDevice80211Wireless *device,
+                                        const char *path,
+                                        gboolean create_if_not_found);
 
 static void
 nm_device_802_11_wireless_init (NMDevice80211Wireless *device)
@@ -38,6 +76,67 @@ nm_device_802_11_wireless_init (NMDevice80211Wireless *device)
 	                                   (GDestroyNotify) g_object_unref);
 }
 
+static void
+get_property (GObject *object,
+              guint prop_id,
+              GValue *value,
+              GParamSpec *pspec)
+{
+	NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (object);
+
+	switch (prop_id) {
+	case PROP_HW_ADDRESS:
+		g_value_set_string (value, priv->hw_address);
+		break;
+	case PROP_MODE:
+		g_value_set_int (value, priv->mode);
+		break;
+	case PROP_BITRATE:
+		g_value_set_int (value, priv->rate);
+		break;
+	case PROP_ACTIVE_ACCESS_POINT:
+		g_value_set_object (value, priv->current_ap);
+		break;
+	case PROP_WIRELESS_CAPABILITIES:
+		g_value_set_uint (value, priv->wireless_caps);
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+		break;
+	}
+}
+
+static void
+state_changed_cb (NMDevice *device, NMDeviceState state, gpointer user_data)
+{
+	NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (device);
+
+	switch (state) {
+	case NM_DEVICE_STATE_PREPARE:
+	case NM_DEVICE_STATE_CONFIG:
+	case NM_DEVICE_STATE_NEED_AUTH:
+	case NM_DEVICE_STATE_IP_CONFIG:
+	case NM_DEVICE_STATE_ACTIVATED:
+		break;
+	case NM_DEVICE_STATE_UNKNOWN:
+	case NM_DEVICE_STATE_DOWN:
+	case NM_DEVICE_STATE_DISCONNECTED:
+	case NM_DEVICE_STATE_FAILED:
+	case NM_DEVICE_STATE_CANCELLED:
+	default:
+		if (priv->current_ap) {
+			g_object_unref (priv->current_ap);
+			priv->current_ap = NULL;
+			g_object_notify (G_OBJECT (device), NM_DEVICE_802_11_WIRELESS_PROP_ACTIVE_ACCESS_POINT);
+		}
+		if (priv->rate != 0) {
+			priv->rate = 0;
+			g_object_notify (G_OBJECT (device), NM_DEVICE_802_11_WIRELESS_PROP_BITRATE);
+		}
+		break;
+	}
+}
+
 static GObject*
 constructor (GType type,
 			 guint n_construct_params,
@@ -59,16 +158,34 @@ constructor (GType type,
 													  nm_object_get_path (NM_OBJECT (object)),
 													  NM_DBUS_INTERFACE_DEVICE_WIRELESS);
 
-	dbus_g_proxy_add_signal (priv->wireless_proxy, "AccessPointAdded", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
+	dbus_g_proxy_add_signal (priv->wireless_proxy, "AccessPointAdded",
+	                         DBUS_TYPE_G_OBJECT_PATH,
+	                         G_TYPE_INVALID);
 	dbus_g_proxy_connect_signal (priv->wireless_proxy, "AccessPointAdded",
 								 G_CALLBACK (access_point_added_proxy),
 								 object, NULL);
 
-	dbus_g_proxy_add_signal (priv->wireless_proxy, "AccessPointRemoved", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
+	dbus_g_proxy_add_signal (priv->wireless_proxy, "AccessPointRemoved",
+	                         DBUS_TYPE_G_OBJECT_PATH,
+	                         G_TYPE_INVALID);
 	dbus_g_proxy_connect_signal (priv->wireless_proxy, "AccessPointRemoved",
 								 G_CALLBACK (access_point_removed_proxy),
 								 object, NULL);
 
+	dbus_g_proxy_add_signal (priv->wireless_proxy, "PropertiesChanged",
+	                         dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_VALUE),
+	                         G_TYPE_INVALID);
+	dbus_g_proxy_connect_signal (priv->wireless_proxy,
+								 "PropertiesChanged",
+								 G_CALLBACK (properties_changed_proxy),
+								 NM_DEVICE_802_11_WIRELESS (object),
+								 NULL);
+
+	g_signal_connect (NM_DEVICE (object),
+	                  "state-changed",
+	                  G_CALLBACK (state_changed_cb),
+	                  NULL);
+
 	return object;
 }
 
@@ -84,6 +201,12 @@ dispose (GObject *object)
 
 	g_object_unref (priv->wireless_proxy);
 
+	g_hash_table_destroy (priv->aps);
+	priv->aps = NULL;
+
+	if (priv->current_ap)
+		g_object_unref (priv->current_ap);
+
 	G_OBJECT_CLASS (nm_device_802_11_wireless_parent_class)->dispose (object);
 }
 
@@ -92,7 +215,8 @@ finalize (GObject *object)
 {
 	NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (object);
 
-	g_hash_table_destroy (priv->aps);
+	if (priv->hw_address)
+		g_free (priv->hw_address);
 
 	G_OBJECT_CLASS (nm_device_802_11_wireless_parent_class)->finalize (object);
 }
@@ -106,9 +230,51 @@ nm_device_802_11_wireless_class_init (NMDevice80211WirelessClass *device_class)
 
 	/* virtual methods */
 	object_class->constructor = constructor;
+	object_class->get_property = get_property;
 	object_class->dispose = dispose;
 	object_class->finalize = finalize;
 
+	/* properties */
+	g_object_class_install_property
+		(object_class, PROP_HW_ADDRESS,
+		 g_param_spec_string (NM_DEVICE_802_11_WIRELESS_PROP_HW_ADDRESS,
+							  "MAC Address",
+							  "Hardware MAC address",
+							  NULL,
+							  G_PARAM_READABLE));
+
+	g_object_class_install_property
+		(object_class, PROP_MODE,
+		 g_param_spec_int (NM_DEVICE_802_11_WIRELESS_PROP_MODE,
+		                    "Mode",
+		                    "Mode",
+		                    0, IW_MODE_INFRA, 0,
+		                    G_PARAM_READABLE));
+
+	g_object_class_install_property
+		(object_class, PROP_BITRATE,
+		 g_param_spec_int (NM_DEVICE_802_11_WIRELESS_PROP_BITRATE,
+		                    "Bit Rate",
+		                    "Bit Rate",
+		                    0, G_MAXINT32, 0,
+		                    G_PARAM_READABLE));
+
+	g_object_class_install_property
+		(object_class, PROP_ACTIVE_ACCESS_POINT,
+		 g_param_spec_object (NM_DEVICE_802_11_WIRELESS_PROP_ACTIVE_ACCESS_POINT,
+		                    "Active Access Point",
+		                    "Active Access Point",
+		                    nm_access_point_get_type (),
+		                    G_PARAM_READABLE));
+
+	g_object_class_install_property
+		(object_class, PROP_WIRELESS_CAPABILITIES,
+		 g_param_spec_uint (NM_DEVICE_802_11_WIRELESS_PROP_WIRELESS_CAPABILITIES,
+		                    "Wireless Capabilities",
+		                    "Wireless Capabilities",
+		                    0, G_MAXUINT32, 0,
+		                    G_PARAM_READABLE));
+
 	/* signals */
 	signals[ACCESS_POINT_ADDED] =
 		g_signal_new ("access-point-added",
@@ -143,36 +309,146 @@ nm_device_802_11_wireless_new (DBusGConnection *connection, const char *path)
 												   NULL);
 }
 
+static void
+handle_property_changed (gpointer key, gpointer data, gpointer user_data)
+{
+	NMDevice80211Wireless *self = NM_DEVICE_802_11_WIRELESS (user_data);
+	NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (self);
+	char *g_propname = NULL;
+	GValue *value = (GValue *) data;
+	gboolean success = TRUE;
+
+	if (!strcmp (key, DBUS_PROP_HW_ADDRESS)) {
+		g_propname = NM_DEVICE_802_11_WIRELESS_PROP_HW_ADDRESS;
+		if (G_VALUE_HOLDS_STRING (value))
+			priv->hw_address = g_strdup (g_value_get_string (value));
+	} else if (!strcmp (key, DBUS_PROP_MODE)) {
+		g_propname = NM_DEVICE_802_11_WIRELESS_PROP_MODE;
+		if (G_VALUE_HOLDS_INT (value))
+			priv->mode = g_value_get_int (value);
+	} else if (!strcmp (key, DBUS_PROP_BITRATE)) {
+		g_propname = NM_DEVICE_802_11_WIRELESS_PROP_BITRATE;
+		if (G_VALUE_HOLDS_INT (value))
+			priv->rate = g_value_get_int (value);
+	} else if (!strcmp (key, DBUS_PROP_ACTIVE_ACCESS_POINT)) {
+		g_propname = NM_DEVICE_802_11_WIRELESS_PROP_ACTIVE_ACCESS_POINT;
+		if (G_VALUE_HOLDS_BOXED (value)) {
+			const char *path = g_value_get_boxed (value);
+
+			if (priv->current_ap) {
+				g_object_unref (priv->current_ap);
+				priv->current_ap = NULL;
+			}
+
+			if (path && (strcmp (path, "/") != 0)) {
+				priv->current_ap = get_access_point (self, (const char *) path, TRUE);
+				if (priv->current_ap)
+					g_object_ref (priv->current_ap);
+			}
+		}
+	} else if (!strcmp (key, DBUS_PROP_WIRELESS_CAPABILITIES)) {
+		g_propname = NM_DEVICE_802_11_WIRELESS_PROP_WIRELESS_CAPABILITIES;
+		if (G_VALUE_HOLDS_UINT (value))
+			priv->wireless_caps = g_value_get_uint (value);
+	} else {
+		success = FALSE;
+	}
+
+	if (success) {
+		g_object_notify (G_OBJECT (self), g_propname);
+	}
+}
+
+static void
+properties_changed_proxy (DBusGProxy *proxy,
+                          GHashTable *properties,
+                          gpointer user_data)
+{
+	NMDevice80211Wireless *self = NM_DEVICE_802_11_WIRELESS (user_data);
+
+	g_hash_table_foreach (properties, handle_property_changed, self);
+}
+
 char *
 nm_device_802_11_wireless_get_hw_address (NMDevice80211Wireless *device)
 {
+	NMDevice80211WirelessPrivate *priv;
+
 	g_return_val_if_fail (NM_IS_DEVICE_802_11_WIRELESS (device), NULL);
 
-	return nm_object_get_string_property (NM_OBJECT (device), NM_DBUS_INTERFACE_DEVICE_WIRELESS, "HwAddress");
+	priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (device);
+	if (!priv->hw_address) {
+		priv->hw_address = nm_object_get_string_property (NM_OBJECT (device),
+		                                                  NM_DBUS_INTERFACE_DEVICE_WIRELESS,
+		                                                  DBUS_PROP_HW_ADDRESS);
+	}
+
+	return priv->hw_address;
 }
 
 int
 nm_device_802_11_wireless_get_mode (NMDevice80211Wireless *device)
 {
+	NMDevice80211WirelessPrivate *priv;
+
 	g_return_val_if_fail (NM_IS_DEVICE_802_11_WIRELESS (device), 0);
 
-	return nm_object_get_int_property (NM_OBJECT (device), NM_DBUS_INTERFACE_DEVICE_WIRELESS, "Mode");
+	priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (device);
+	if (!priv->mode) {
+		priv->mode = nm_object_get_int_property (NM_OBJECT (device),
+		                                         NM_DBUS_INTERFACE_DEVICE_WIRELESS,
+		                                         DBUS_PROP_MODE);
+	}
+
+	return priv->mode;
 }
 
 int
 nm_device_802_11_wireless_get_bitrate (NMDevice80211Wireless *device)
 {
+	NMDevice80211WirelessPrivate *priv;
+	NMDeviceState state;
+
 	g_return_val_if_fail (NM_IS_DEVICE_802_11_WIRELESS (device), 0);
 
-	return nm_object_get_int_property (NM_OBJECT (device), NM_DBUS_INTERFACE_DEVICE_WIRELESS, "Bitrate");
+	state = nm_device_get_state (NM_DEVICE (device));
+	switch (state) {
+	case NM_DEVICE_STATE_PREPARE:
+	case NM_DEVICE_STATE_CONFIG:
+	case NM_DEVICE_STATE_NEED_AUTH:
+	case NM_DEVICE_STATE_IP_CONFIG:
+	case NM_DEVICE_STATE_ACTIVATED:
+		break;
+	default:
+		return 0;
+		break;
+	}
+
+	priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (device);
+	if (!priv->rate) {
+		priv->rate = nm_object_get_int_property (NM_OBJECT (device),
+		                                         NM_DBUS_INTERFACE_DEVICE_WIRELESS,
+		                                         DBUS_PROP_BITRATE);
+	}
+
+	return priv->rate;
 }
 
 guint32
 nm_device_802_11_wireless_get_capabilities (NMDevice80211Wireless *device)
 {
+	NMDevice80211WirelessPrivate *priv;
+
 	g_return_val_if_fail (NM_IS_DEVICE_802_11_WIRELESS (device), 0);
 
-	return nm_object_get_uint_property (NM_OBJECT (device), NM_DBUS_INTERFACE_DEVICE_WIRELESS, "WirelessCapabilities");
+	priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (device);
+	if (!priv->wireless_caps) {
+		priv->wireless_caps = nm_object_get_uint_property (NM_OBJECT (device),
+		                                                   NM_DBUS_INTERFACE_DEVICE_WIRELESS,
+		                                                   DBUS_PROP_WIRELESS_CAPABILITIES);
+	}
+
+	return priv->wireless_caps;
 }
 
 static NMAccessPoint *
@@ -194,18 +470,38 @@ get_access_point (NMDevice80211Wireless *device, const char *path, gboolean crea
 NMAccessPoint *
 nm_device_802_11_wireless_get_active_access_point (NMDevice80211Wireless *device)
 {
-	char *path;
+	NMDevice80211WirelessPrivate *priv;
-	NMAccessPoint *ap = NULL;
+	NMDeviceState state;
 
 	g_return_val_if_fail (NM_IS_DEVICE_802_11_WIRELESS (device), NULL);
 
-	path = nm_object_get_object_path_property (NM_OBJECT (device), NM_DBUS_INTERFACE_DEVICE_WIRELESS, "ActiveAccessPoint");
+	state = nm_device_get_state (NM_DEVICE (device));
-	if (path) {
+	switch (state) {
-		ap = get_access_point (device, path, TRUE);
+	case NM_DEVICE_STATE_PREPARE:
+	case NM_DEVICE_STATE_CONFIG:
+	case NM_DEVICE_STATE_NEED_AUTH:
+	case NM_DEVICE_STATE_IP_CONFIG:
+	case NM_DEVICE_STATE_ACTIVATED:
+		break;
+	default:
+		return NULL;
+		break;
+	}
+
+	priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (device);
+	if (!priv->current_ap) {
+		char *path;
+
+		path = nm_object_get_object_path_property (NM_OBJECT (device),
+		                                           NM_DBUS_INTERFACE_DEVICE_WIRELESS,
+		                                           DBUS_PROP_ACTIVE_ACCESS_POINT);
+		priv->current_ap = get_access_point (device, path, TRUE);
+		if (priv->current_ap)
+			g_object_ref (priv->current_ap);
 		g_free (path);
 	}
 
-	return ap;
+	return priv->current_ap;
 }
 
 NMAccessPoint *