Пример #1
0
static void
adapter_changed (GtkTreeModel *model,
		 GtkTreePath  *path,
		 GtkTreeIter  *iter,
		 GtkNotebook  *notebook)
{
	DBusGProxy *proxy;
	int i, count;
	gboolean is_default, powered;
	char *name;

	count = gtk_notebook_get_n_pages(notebook);

	gtk_tree_model_get(model, iter,
			   BLUETOOTH_COLUMN_PROXY, &proxy,
			   BLUETOOTH_COLUMN_DEFAULT, &is_default,
			   BLUETOOTH_COLUMN_POWERED, &powered,
			   BLUETOOTH_COLUMN_NAME, &name,
			   -1);

	for (i = 0; i < count; i++) {
		GtkWidget *widget;
		adapter_data *adapter;

		widget = gtk_notebook_get_nth_page(notebook, i);
		if (widget == NULL)
			continue;

		adapter = g_object_get_data(G_OBJECT(widget), "adapter");
		if (adapter == NULL)
			continue;

		adapter->is_default = is_default;

		if (proxy == NULL || adapter->proxy == NULL)
			continue;

		if (g_str_equal (dbus_g_proxy_get_path (proxy), dbus_g_proxy_get_path (adapter->proxy)) != FALSE) {
			if (is_default != FALSE && powered != FALSE)
				gtk_notebook_set_current_page (notebook, i);
			/* We usually get an adapter_added before the device
			 * is powered, so we set the name here instead */
			if (name)
				gtk_entry_set_text(GTK_ENTRY(adapter->entry), name);
		}
	}

	g_object_unref (proxy);
	g_free (name);
}
Пример #2
0
int main()
{
	DBusGConnection* connection;
	DBusGProxy* proxy;
	GError* error = NULL;
	
	char* path = "/Test/Proxy/Path";
	
	g_type_init();
	
	connection = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
	if (connection == NULL)
		{
			std_log(LOG_FILENAME_LINE, "Failed to open connection to bus: %s\n",
		              error->message);
		  g_error_free (error);
		  create_xml(1);
		  return 1;
		}
	
	proxy = dbus_g_proxy_new_for_name(connection, "Test.Glib.Proxy.Path", path, "Test.Proxy.Interface");
	
	if(strcmp(path, dbus_g_proxy_get_path(proxy)))
		{
		std_log(LOG_FILENAME_LINE, "Fail to check interface %s", path);
		create_xml(1);
		return 1;
		}
	
	std_log(LOG_FILENAME_LINE, "Test Successful");
	create_xml(0);
	return 0;
}
Пример #3
0
static void method_call(DBusGProxy *proxy, const char *method, const char *path)
{
	if (proxy == NULL)
		return;

	g_print("%s ( %s, %s )\n", method, dbus_g_proxy_get_path(proxy), path);

	if (path == NULL) {
		if (dbus_g_proxy_begin_call_with_timeout(proxy,
					method, method_callback, NULL, NULL,
					120 * 1000, G_TYPE_INVALID) == FALSE) {
			g_print("Can't call method %s\n", method);
			g_object_unref(proxy);
			return;
		}
	} else {
		if (dbus_g_proxy_begin_call(proxy, method, method_callback,
				NULL, NULL, DBUS_TYPE_G_OBJECT_PATH, path,
						G_TYPE_INVALID) == FALSE) {
			g_print("Can't call method %s (%s)\n", method, path);
			g_object_unref(proxy);
			return;
		}
	}
}
Пример #4
0
static void
set_network_cb (DBusGProxy *proxy, DBusGProxyCall *call_id, gpointer user_data)
{
	NMSupplicantInfo *info = (NMSupplicantInfo *) user_data;
	NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (info->interface);
	GError *err = NULL;
	guint tmp;

	if (!dbus_g_proxy_end_call (proxy, call_id, &err, G_TYPE_UINT, &tmp, G_TYPE_INVALID)) {
		nm_log_warn (LOGD_SUPPLICANT, "Couldn't set network config: %s.", err->message);
		emit_error_helper (info->interface, err);
		g_error_free (err);
	} else {
		DBusGProxyCall *call;

		info = nm_supplicant_info_new (info->interface, priv->iface_proxy, priv->assoc_pcalls);
		call = dbus_g_proxy_begin_call (priv->iface_proxy, "selectNetwork",
		                                select_network_cb,
		                                info,
		                                nm_supplicant_info_destroy,
		                                DBUS_TYPE_G_OBJECT_PATH, dbus_g_proxy_get_path (proxy),
		                                G_TYPE_INVALID);
		nm_supplicant_info_set_call (info, call);
	}
}
Пример #5
0
static void connect_callback(GtkButton *button, gpointer user_data)
{
    GtkTreeModel *model;
    GtkTreeIter iter;
    DBusGProxy *proxy;
    const gchar *path;
    gboolean enabled;

    if (gtk_tree_selection_get_selected(selection, &model, &iter) == FALSE)
        return;

    gtk_tree_model_get(model, &iter, CONNMAN_COLUMN_PROXY, &proxy,
                       CONNMAN_COLUMN_ENABLED, &enabled, -1);

    path = dbus_g_proxy_get_path(proxy);

    if (enabled == FALSE)
        connman_client_connect(client, path);
    else
        connman_client_disconnect(client, path);

    g_object_unref(proxy);

    if (enabled == FALSE)
        g_object_set(button_connect,
                     "label", GTK_STOCK_DISCONNECT, NULL);
    else
        g_object_set(button_connect,
                     "label", GTK_STOCK_CONNECT, NULL);
}
Пример #6
0
gboolean
_nm_dbus_get_property (DBusGProxy *proxy,
					  const char *interface,
					  const char *prop_name,
					  GValue *value)
{
	DBusGProxy *properties_proxy;
	GError *err = NULL;
	gboolean ret = TRUE;

	g_return_val_if_fail (proxy != NULL, FALSE);
	g_return_val_if_fail (interface != NULL, FALSE);
	g_return_val_if_fail (prop_name != NULL, FALSE);

	properties_proxy = dbus_g_proxy_new_from_proxy (proxy,
													"org.freedesktop.DBus.Properties",
													dbus_g_proxy_get_path (proxy));

	if (!dbus_g_proxy_call (properties_proxy, "Get", &err,
							G_TYPE_STRING, interface,
							G_TYPE_STRING, prop_name,
							G_TYPE_INVALID,
							G_TYPE_VALUE, value,
							G_TYPE_INVALID)) {
		g_warning ("Error in device_get_property: %s\n", err->message);
		g_error_free (err);
		ret = FALSE;
	}

	g_object_unref (properties_proxy);

	return ret;
}
Пример #7
0
static void changed_callback(GtkComboBox *combo, gpointer user_data)
{
    GtkTreeModel *model = gtk_combo_box_get_model(combo);
    GtkTreeIter iter;
    DBusGProxy *proxy;
    gchar *path;
    gboolean enabled;

    if (gtk_combo_box_get_active_iter(combo, &iter) == FALSE)
        return;

    path = g_object_get_data(G_OBJECT(button_enabled), "device");
    g_free(path);

    gtk_tree_model_get(model, &iter, CONNMAN_COLUMN_PROXY, &proxy,
                       CONNMAN_COLUMN_ENABLED, &enabled, -1);

    path = g_strdup(dbus_g_proxy_get_path(proxy));
    g_object_set_data(G_OBJECT(button_enabled), "device", path);

    g_object_unref(proxy);

    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_enabled),
                                 enabled);

    gtk_widget_set_sensitive(button_refresh, enabled);

    model = connman_client_get_network_model(client, path);
    gtk_tree_view_set_model(GTK_TREE_VIEW(tree_networks), model);
    g_object_unref(model);
}
Пример #8
0
static gboolean
network_model_have_service_in_store (GtkListStore *store,
                                     GtkTreeIter  *iter,
                                     const gchar  *path)
{
  gboolean    cont, found = FALSE;
  DBusGProxy *service;

  cont = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store),
                                        iter);

  while (cont)
    {
      gtk_tree_model_get (GTK_TREE_MODEL (store),
                          iter,
                          CARRICK_COLUMN_PROXY, &service,
                          -1);

      if (!service)
        break;

      found = g_str_equal (path,
                           dbus_g_proxy_get_path (service));
      g_object_unref (service);

      if (found)
        break;

      cont = gtk_tree_model_iter_next (GTK_TREE_MODEL (store),
                                       iter);
    }

  return found;
}
Пример #9
0
static void
modem_removed (DBusGProxy *proxy, const char *path, gpointer user_data)
{
	PluginInfo *info = user_data;
	GSList *iter;
	DBusGProxy *found = NULL;

	g_return_if_fail (path != NULL);

	g_message ("%s: (%s) modem removed", __func__, path);

	/* Clean up if a modem gets removed */

	for (iter = info->modem_proxies; iter; iter = g_slist_next (iter)) {
		if (!strcmp (path, dbus_g_proxy_get_path (DBUS_G_PROXY (iter->data)))) {
			found = iter->data;
			break;
		}
	}

	if (found) {
		info->modem_proxies = g_slist_remove (info->modem_proxies, found);
		g_object_unref (found);
	}
}
Пример #10
0
static gboolean cancel_request(DBusGMethodInvocation *context,
							gpointer user_data)
{
	DBusGProxy *adapter = user_data;
	GList *list;
	GError *result;
	input_data *input;

	input = g_new0(input_data, 1);
	input->path = g_strdup(dbus_g_proxy_get_path(adapter));

	list = g_list_find_custom(input_list, input, input_compare);

	g_free(input->path);
	g_free(input);

	if (!list || !list->data)
		return FALSE;

	input = list->data;

	close_notification();

	result = g_error_new(AGENT_ERROR, AGENT_ERROR_REJECT,
						"Agent callback cancelled");

	dbus_g_method_return_error(input->context, result);

	input_free(input);

	return TRUE;
}
static void
modem_set_net_reg (Modem *modem, gboolean net_reg)
{
	GList *netops;

	g_free (modem->cid);
	modem->cid = NULL;
	g_free (modem->lac);
	modem->lac = NULL;

	if (modem->netreg_proxy) {
		dbus_g_proxy_disconnect_signal (modem->netreg_proxy, "PropertyChanged",
		                                G_CALLBACK (netreg_property_changed_cb),
		                                modem);
		g_object_unref (modem->netreg_proxy);
		modem->netreg_proxy = NULL;
	}

	for (netops = modem->netops; netops; netops = netops->next) {
		net_op_free ((NetOp*)netops->data);
	}
	g_list_free (modem->netops);
	modem->netops = NULL;

	if (net_reg) {
		modem->netreg_proxy = dbus_g_proxy_new_from_proxy (modem->proxy,
		                                                   "org.ofono.NetworkRegistration",
		                                                   dbus_g_proxy_get_path (modem->proxy));
		if (!modem->netreg_proxy) {
			g_warning ("failed to find the oFono NetworkRegistration '%s'",
			           dbus_g_proxy_get_path (modem->proxy));
		} else {
			org_ofono_NetworkRegistration_get_properties_async (modem->netreg_proxy,
																(org_ofono_NetworkRegistration_get_properties_reply)net_reg_get_properties_cb,
																modem);
			dbus_g_proxy_add_signal (modem->netreg_proxy,"PropertyChanged",
									 G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID);
			dbus_g_proxy_connect_signal (modem->netreg_proxy, "PropertyChanged",
										 G_CALLBACK (netreg_property_changed_cb),
										 modem, NULL);
		}
	}
}
/* This is the handler for the Changed() signal emitted by UDisks. */
static void udisks_changed_signal_cb(DBusGProxy *sensor_proxy) {
	const gchar *path = dbus_g_proxy_get_path(sensor_proxy);
	DevInfo *info;

	info = g_hash_table_lookup(devices, path);
	if (info)
	{
		info->changed = TRUE;
	}
}
static void
_list_contains_child (GtkWidget *item,
                      find_data *data)
{
  CarrickServiceItem *service_item = CARRICK_SERVICE_ITEM (item);
  DBusGProxy         *proxy = carrick_service_item_get_proxy (service_item);
  const gchar        *path;
  const gchar        *data_path = dbus_g_proxy_get_path (data->service);

  if (proxy)
    {
      path = dbus_g_proxy_get_path (proxy);

      if (g_str_equal (data_path, path))
        {
          data->widget = item;
        }
    }
}
Пример #14
0
static int
compare_device_path (NMDevice *nm_device, char *device_path)
{
     const char *path;

     path = dbus_g_proxy_get_path (nm_device->device_proxy);
     if (G_UNLIKELY (path == NULL))
             return -1;

     return strcmp (path, device_path);
}
Пример #15
0
static void
auth_dialog (DBusGProxy *adapter,
	     DBusGProxy *device,
	     const char *name,
	     const char *long_name,
	     const char *uuid,
	     DBusGMethodInvocation *context)
{
	GtkBuilder *xml;
	GtkWidget *dialog;
	GtkWidget *button;
	char *str;
	input_data *input;

	input = g_new0 (input_data, 1);
	input->path = g_strdup (dbus_g_proxy_get_path (adapter));
	input->uuid = g_strdup (uuid);
	input->device = g_object_ref (device);
	input->context = context;

	xml = gtk_builder_new ();
	if (gtk_builder_add_from_file (xml, "authorisation-dialogue.ui", NULL) == 0)
		gtk_builder_add_from_file (xml, PKGDATADIR "/authorisation-dialogue.ui", NULL);

	dialog = GTK_WIDGET (gtk_builder_get_object (xml, "dialog"));
	gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
	if (notification_supports_actions () != FALSE)
		gtk_window_set_keep_above (GTK_WINDOW (dialog), TRUE);
	else
		gtk_window_set_focus_on_map (GTK_WINDOW (dialog), FALSE);
	gtk_window_set_urgency_hint (GTK_WINDOW (dialog), TRUE);
	input->dialog = dialog;

	/* translators: Whether to grant access to a particular service */
	str = g_strdup_printf (_("Grant access to '%s'"), uuid);
	g_object_set (G_OBJECT (dialog), "text", str, NULL);
	g_free (str);

	gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
						  _("Device %s wants access to the service '%s'."),
						  long_name, uuid);

	button = GTK_WIDGET (gtk_builder_get_object (xml, "always_button"));
	input->button = button;

	input_list = g_list_append (input_list, input);

	g_signal_connect (G_OBJECT (dialog), "response",
			  G_CALLBACK (auth_callback), input);

	enable_blinking ();
}
Пример #16
0
static gboolean
network_model_have_service_by_proxy (GtkListStore *store,
                                     GtkTreeIter  *iter,
                                     DBusGProxy   *service)
{
  const gchar *path;

  if (!service)
    return FALSE;

  path = dbus_g_proxy_get_path (service);

  return network_model_have_service_by_path (store, iter, path);
}
Пример #17
0
static void
confirm_dialog (DBusGProxy *adapter,
		DBusGProxy *device,
		const char *name,
		const char *long_name,
		const char *value,
		DBusGMethodInvocation *context)
{
	GtkWidget *dialog;
	GtkBuilder *xml;
	char *str;
	input_data *input;

	input = g_new0 (input_data, 1);
	input->path = g_strdup (dbus_g_proxy_get_path(adapter));
	input->device = g_object_ref (device);
	input->context = context;

	xml = gtk_builder_new ();
	if (gtk_builder_add_from_file (xml, "confirm-dialogue.ui", NULL) == 0)
		gtk_builder_add_from_file (xml, PKGDATADIR "/confirm-dialogue.ui", NULL);

	dialog = GTK_WIDGET (gtk_builder_get_object (xml, "dialog"));
	gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
	if (notification_supports_actions () != FALSE)
		gtk_window_set_keep_above (GTK_WINDOW (dialog), TRUE);
	else
		gtk_window_set_focus_on_map (GTK_WINDOW (dialog), FALSE);
	gtk_window_set_urgency_hint (GTK_WINDOW (dialog), TRUE);
	input->dialog = dialog;

	str = g_strdup_printf (_("Device '%s' wants to pair with this computer"),
			       name);
	g_object_set (G_OBJECT (dialog), "text", str, NULL);
	g_free (str);

	str = g_strdup_printf ("<b>%s</b>", value);
	gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog),
						    _("Please confirm whether the PIN '%s' matches the one on device %s."),
						    str, long_name);
	g_free (str);

	input_list = g_list_append (input_list, input);

	g_signal_connect (G_OBJECT (dialog), "response",
			  G_CALLBACK (confirm_callback), input);

	enable_blinking ();
}
Пример #18
0
void
nm_supplicant_interface_disconnect (NMSupplicantInterface * self)
{
	NMSupplicantInterfacePrivate *priv;

	g_return_if_fail (NM_IS_SUPPLICANT_INTERFACE (self));

	priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self);

	/* Clear and cancel all pending calls related to a prior
	 * connection attempt.
	 */
	cancel_all_callbacks (priv->assoc_pcalls);

	/* Don't do anything if there is no connection to the supplicant yet. */
	if (!priv->iface_proxy)
		return;

	/* Don't try to disconnect if the supplicant interface is already
	 * disconnected.
	 */
	if (priv->con_state == NM_SUPPLICANT_INTERFACE_CON_STATE_DISCONNECTED
	    || priv->con_state == NM_SUPPLICANT_INTERFACE_CON_STATE_INACTIVE) {
		if (priv->net_proxy) {
			g_object_unref (priv->net_proxy);
			priv->net_proxy = NULL;
		}

		return;
	}

	/* Remove any network that was added by NetworkManager */
	if (priv->net_proxy) {
		dbus_g_proxy_begin_call (priv->iface_proxy, "removeNetwork",
		                         remove_network_cb,
		                         NULL, NULL,
		                         DBUS_TYPE_G_OBJECT_PATH, dbus_g_proxy_get_path (priv->net_proxy),
		                         G_TYPE_INVALID);

		g_object_unref (priv->net_proxy);
		priv->net_proxy = NULL;
	}

	dbus_g_proxy_begin_call (priv->iface_proxy, "disconnect",
	                         disconnect_cb,
	                         NULL, NULL,
	                         G_TYPE_INVALID);
}
Пример #19
0
static void drag_data_received(GtkWidget *widget, GdkDragContext *context,
				gint x, gint y, GtkSelectionData *data,
				guint info, guint time, gpointer user_data)
{
	GtkTreeModel *model = user_data;
	GtkTreePath *path;
	GtkTreeIter iter;
	DBusGProxy *source, *proxy = NULL;
	gboolean success = FALSE;

	if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget),
				x, y, &path, NULL, NULL, NULL) == FALSE)
		return;

	if (gtk_tree_model_get_iter(model, &iter, path) == FALSE)
		goto done;

	gtk_tree_model_get(model, &iter, CONNMAN_COLUMN_PROXY, &proxy, -1);

	if (data == NULL || data->length == 0)
		goto done;

	if (info != CONNMAN_SERVICE_MOVE)
		goto done;

	if (gtk_tree_model_get_iter_from_string(model, &iter,
						(gchar *) data->data) == FALSE)
		goto done;

	g_print("%s -> %s\n", (gchar *) data->data, gtk_tree_path_to_string(path));

	gtk_tree_model_get(model, &iter, CONNMAN_COLUMN_PROXY, &source, -1);

	method_call(source, "MoveBefore", dbus_g_proxy_get_path(proxy));

	g_object_unref(proxy);

	success = TRUE;

done:
	gtk_tree_path_free(path);

	gtk_drag_finish(context, success, FALSE, time);
}
Пример #20
0
static void update_service(DBusGProxy *proxy, const char *path)
{
    if (path == NULL) {
        status_offline();
        return;
    }

    if (service != NULL) {
        if (g_strcmp0(dbus_g_proxy_get_path(service), path) == 0)
            return;

        properties_destroy(service);
    }

    service = dbus_g_proxy_new_from_proxy(proxy,
                                          "net.connman.Service", path);

    properties_create(service, service_property_changed, NULL);
}
static void
modem_removed (DBusGProxy *proxy, const char *path, gpointer user_data)
{
	NmaBtDevice *self = NMA_BT_DEVICE (user_data);
	NmaBtDevicePrivate *priv = NMA_BT_DEVICE_GET_PRIVATE (self);
	GSList *iter;

	g_return_if_fail (path != NULL);

	g_message ("%s: (%s) modem removed", __func__, path);

	/* Clean up if a modem gets removed */
	for (iter = priv->modem_proxies; iter; iter = g_slist_next (iter)) {
		if (!strcmp (path, dbus_g_proxy_get_path (DBUS_G_PROXY (iter->data)))) {
			priv->modem_proxies = g_slist_remove (priv->modem_proxies, iter->data);
			g_object_unref (iter->data);
			break;
		}
	}
}
Пример #22
0
void
_nm_dbus_set_property (DBusGProxy *proxy,
					  const char *interface,
					  const char *prop_name,
					  GValue *value)
{
	DBusGProxy *properties_proxy;

	g_return_if_fail (proxy != NULL);
	g_return_if_fail (interface != NULL);
	g_return_if_fail (prop_name != NULL);

	properties_proxy = dbus_g_proxy_new_from_proxy (proxy,
													"org.freedesktop.DBus.Properties",
													dbus_g_proxy_get_path (proxy));

	dbus_g_proxy_call_no_reply (properties_proxy, "Set",
								G_TYPE_STRING, interface,
								G_TYPE_STRING, prop_name,
								G_TYPE_VALUE, value,
								G_TYPE_INVALID);

	g_object_unref (properties_proxy);
}
Пример #23
0
static void udisks_device_umount_cb(DBusGProxy *proxy, GError *error, gpointer userdata)
{
	wmvm_volume_set_error(dbus_g_proxy_get_path(proxy), error != NULL);
	return;
}
static void
modem_get_all_cb (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data)
{
	NmaBtDevice *self = NMA_BT_DEVICE (user_data);
	NmaBtDevicePrivate *priv = NMA_BT_DEVICE_GET_PRIVATE (self);
	const char *path;
	GHashTable *properties = NULL;
	GError *error = NULL;
	GValue *value;
	NMDeviceType devtype = NM_DEVICE_TYPE_UNKNOWN;

	path = dbus_g_proxy_get_path (proxy);
	g_message ("%s: (%s) processing GetAll reply", __func__, path);

	if (!dbus_g_proxy_end_call (proxy, call, &error,
	                            DBUS_TYPE_G_MAP_OF_VARIANT, &properties,
	                            G_TYPE_INVALID)) {
		g_warning ("%s: (%s) Error getting modem properties: (%d) %s",
		           __func__,
		           path,
		           error ? error->code : -1,
		           (error && error->message) ? error->message : "(unknown)");
		g_error_free (error);
		goto out;
	}

	/* check whether this is the device we care about */
	value = g_hash_table_lookup (properties, "Device");
	if (value && G_VALUE_HOLDS_STRING (value) && g_value_get_string (value)) {
		char *iface_basename = g_path_get_basename (priv->rfcomm_iface);
		const char *modem_iface = g_value_get_string (value);

		if (strcmp (iface_basename, modem_iface) == 0) {
			/* yay, found it! */

			value = g_hash_table_lookup (properties, "Type");
			if (value && G_VALUE_HOLDS_UINT (value)) {
				switch (g_value_get_uint (value)) {
				case 1:
					devtype = NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS;
					break;
				case 2:
					devtype = NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO;
					break;
				default:
					g_message ("%s: (%s) unknown modem type", __func__, path);
					break;
				}
			}
		} else {
			g_message ("%s: (%s) (%s) not the modem we're looking for (%s)",
			           __func__, path, modem_iface, iface_basename);
		}

		g_free (iface_basename);
	} else
		g_message ("%s: (%s) modem had no 'Device' property", __func__, path);

	g_hash_table_unref (properties);

	/* Launch wizard! */
	start_wizard (self, path, devtype);

out:
	g_message ("%s: finished", __func__);
}
static void
carrick_list_drag_end (GtkWidget      *widget,
                       GdkDragContext *context,
                       CarrickList    *list)
{
  CarrickListPrivate *priv = list->priv;
  GList              *children;

  children = gtk_container_get_children (GTK_CONTAINER (priv->box));

  /* destroy the popup window */
  g_object_ref (widget);
  gtk_container_remove (GTK_CONTAINER (priv->drag_window), widget);
  gtk_widget_destroy (priv->drag_window);
  priv->drag_window = NULL;

  /* insert the widget into the list */
  gtk_box_pack_start (GTK_BOX (priv->box), widget,
                      FALSE, FALSE, 2);
  gtk_box_reorder_child (GTK_BOX (priv->box),
                         widget,
                         priv->drop_position);
  g_object_unref (widget);

  if (priv->drop_position != priv->drag_position)
    {
      GtkWidget   *other_widget;
      DBusGProxy  *service, * other_service;
      const gchar *path;
      move_data   *data = NULL;

      service = carrick_service_item_get_proxy (CARRICK_SERVICE_ITEM (widget));
      data = g_slice_new0 (move_data);
      data->list = GTK_WIDGET (list->priv->box);
      data->item = widget;
      data->pos = priv->drag_position;

      if (priv->drop_position == 0)
        {
          other_widget = g_list_nth_data (children, 0);
          other_service = carrick_service_item_get_proxy
                    (CARRICK_SERVICE_ITEM (other_widget));
          path = dbus_g_proxy_get_path (other_service);

          net_connman_Service_move_before_async (service,
                                                 path,
                                                 move_notify_cb,
                                                 data);
        }
      else
        {
          other_widget = g_list_nth_data (children,
                                          priv->drop_position - 1);

          other_service = carrick_service_item_get_proxy
                    (CARRICK_SERVICE_ITEM (other_widget));
          path = dbus_g_proxy_get_path (other_service);

          net_connman_Service_move_after_async (service,
                                                path,
                                                move_notify_cb,
                                                data);
        }
    }

  g_list_free (children);
}
Пример #26
0
static void create_adapter(adapter_data *adapter)
{
	GHashTable *hash = NULL;
	GValue *value;
	DBusGProxy *default_proxy;
	const gchar *name;
	gboolean powered, discoverable;
	guint timeout;

	GtkWidget *mainbox;
	GtkWidget *vbox;
	GtkWidget *alignment;
	GtkWidget *table;
	GtkWidget *label;
	GtkWidget *image;
	GtkWidget *button;
	GtkWidget *entry;
	GtkWidget *buttonbox;
	int page_num;

	dbus_g_proxy_call(adapter->proxy, "GetProperties", NULL, G_TYPE_INVALID,
				dbus_g_type_get_map("GHashTable",
						G_TYPE_STRING, G_TYPE_VALUE),
				&hash, G_TYPE_INVALID);

	if (hash != NULL) {
		value = g_hash_table_lookup(hash, "Name");
		name = value ? g_value_get_string(value) : NULL;

		value = g_hash_table_lookup(hash, "Powered");
		powered = value ? g_value_get_boolean(value) : FALSE;

		value = g_hash_table_lookup(hash, "Discoverable");
		discoverable = value ? g_value_get_boolean(value) : FALSE;

		value = g_hash_table_lookup(hash, "DiscoverableTimeout");
		timeout = value ? g_value_get_uint(value) : 0;
	} else {
		name = NULL;
		powered = FALSE;
		discoverable = FALSE;
		timeout = 0;
	}

	adapter->powered = powered;
	adapter->discoverable = discoverable;
	adapter->timeout_value = timeout;

	default_proxy = bluetooth_client_get_default_adapter (client);
	if (default_proxy != NULL) {
		adapter->is_default = g_str_equal (dbus_g_proxy_get_path (default_proxy),
						   dbus_g_proxy_get_path (adapter->proxy));
		g_object_unref (default_proxy);
	}

	mainbox = gtk_vbox_new(FALSE, 6);
	gtk_container_set_border_width(GTK_CONTAINER(mainbox), 12);

	page_num = gtk_notebook_prepend_page(GTK_NOTEBOOK(adapter->notebook),
							mainbox, NULL);

	adapter->child = mainbox;

	vbox = gtk_vbox_new(FALSE, 6);
	gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, TRUE, 0);

	/* The discoverable checkbox */
	button = gtk_check_button_new_with_mnemonic (_("Make computer _visible"));
	if (powered == FALSE)
		discoverable = FALSE;
	if (discoverable != FALSE && timeout == 0)
		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
	else if (discoverable == FALSE)
		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE);
	else {
		gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
		gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE);
	}
	gtk_widget_set_sensitive (button, adapter->powered);

	adapter->button_discoverable = button;
	adapter->signal_discoverable = g_signal_connect(G_OBJECT(button), "toggled",
							G_CALLBACK(discoverable_changed_cb), adapter);

	gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0);

	/* The friendly name */
	vbox = gtk_vbox_new(FALSE, 6);
	gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, FALSE, 0);

	label = create_label(_("Friendly name"));
	gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);

	alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
	gtk_widget_show (alignment);
	gtk_box_pack_start (GTK_BOX (vbox), alignment, TRUE, TRUE, 0);
	gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0);

	entry = gtk_entry_new();
	gtk_entry_set_max_length(GTK_ENTRY(entry), 248);
	gtk_widget_set_size_request(entry, 240, -1);
	gtk_container_add (GTK_CONTAINER (alignment), entry);

	if (name != NULL)
		gtk_entry_set_text(GTK_ENTRY(entry), name);

	adapter->entry = entry;
	adapter->name_vbox = vbox;

	g_signal_connect(G_OBJECT(entry), "changed",
					G_CALLBACK(name_callback), adapter);
	g_signal_connect(G_OBJECT(entry), "focus-out-event",
					G_CALLBACK(focus_callback), adapter);

	gtk_widget_set_sensitive (adapter->name_vbox, adapter->powered);

	/* The known devices */
	table = gtk_table_new(2, 2, FALSE);
	gtk_box_pack_start(GTK_BOX(mainbox), table, TRUE, TRUE, 0);

	label = create_label(_("Devices"));
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, 0, 1,
			 GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 6);

	/* Note that this will only ever show the devices on the default
	 * adapter, this is on purpose */
	adapter->chooser = bluetooth_chooser_new (NULL);
	g_object_set (adapter->chooser,
		      "show-searching", FALSE,
		      "show-device-type", FALSE,
		      "show-device-category", FALSE,
		      "show-pairing", TRUE,
		      "show-connected", TRUE,
		      "device-category-filter", BLUETOOTH_CATEGORY_PAIRED_OR_TRUSTED,
		      NULL);

	g_signal_connect (adapter->chooser, "notify::device-selected",
			  G_CALLBACK(device_selected_cb), adapter);

	gtk_table_attach(GTK_TABLE(table), adapter->chooser, 0, 1, 1, 2,
			 GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

	adapter->devices_table = table;

	buttonbox = gtk_vbutton_box_new();
	gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox),
						GTK_BUTTONBOX_START);
	gtk_box_set_spacing(GTK_BOX(buttonbox), 6);
	gtk_box_set_homogeneous(GTK_BOX(buttonbox), FALSE);
	gtk_table_attach(GTK_TABLE(table), buttonbox, 1, 2, 1, 2,
			 GTK_FILL, GTK_FILL, 6, 6);

	button = gtk_button_new_with_mnemonic(_("Set up _new device..."));
	image = gtk_image_new_from_stock(GTK_STOCK_ADD,
						GTK_ICON_SIZE_BUTTON);
	gtk_button_set_image(GTK_BUTTON(button), image);
	gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 0);

	g_signal_connect(G_OBJECT(button), "clicked",
				G_CALLBACK(wizard_callback), adapter);

	button = gtk_button_new_with_label(_("Disconnect"));
	image = gtk_image_new_from_stock(GTK_STOCK_DISCONNECT,
						GTK_ICON_SIZE_BUTTON);
	gtk_button_set_image(GTK_BUTTON(button), image);
	gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0);
	gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox),
								button, TRUE);
	gtk_widget_set_sensitive(button, FALSE);

	g_signal_connect(G_OBJECT(button), "clicked",
				G_CALLBACK(disconnect_callback), adapter);

	adapter->button_disconnect = button;

	button = gtk_button_new_with_mnemonic(_("_Remove"));
	image = gtk_image_new_from_stock(GTK_STOCK_REMOVE,
						GTK_ICON_SIZE_BUTTON);
	gtk_button_set_image(GTK_BUTTON(button), image);
	gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0);
	gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox),
								button, TRUE);
	gtk_widget_set_sensitive(button, FALSE);

	g_signal_connect(G_OBJECT(button), "clicked",
				G_CALLBACK(remove_callback), adapter);

	adapter->button_delete = button;

	gtk_widget_set_sensitive (adapter->devices_table, adapter->powered);

	g_object_set_data(G_OBJECT(mainbox), "adapter", adapter);

	gtk_widget_show_all(mainbox);

	if (adapter->is_default != FALSE)
		gtk_notebook_set_current_page (GTK_NOTEBOOK (adapter->notebook), page_num);
}
Пример #27
0
/**
 * Callback for org.bluez.Adapter.DeviceCreated signal
 */
static void device_created(DBusGProxy *proxy, const char *path, gpointer user_data)
{
	connect_device_signals(path, dbus_g_proxy_get_path(proxy));
	DEBUG("device created: %s", path);
}
Пример #28
0
/**
 * Callback for org.bluez.HealthDevice.ChannelConnected signal
 * Reused by CreateChannel callback (channel initiation)
 */
static void channel_connected(DBusGProxy *proxy, const char *path, gpointer user_data)
{
	int fd;
	guint64 handle;
	device_object *dev;
	const char *device_path;

	channel_object *c = get_channel(path);
	if (c) {
		if (c->initiated_by_us && c->fd >= 0) {
			DEBUG("initiated channel already connected: %s", path);
			return;
		}
	}

	DEBUG("channel connected: %s", path);

	// Need to use non-GLib code here because GLib still does not have
	// the UNIX FD type.

	DBusMessage *msg, *reply;
	DBusError err;

	msg = dbus_message_new_method_call("org.bluez", path,
					   "org.bluez.HealthChannel", "Acquire");

	if (!msg) {
		ERROR(" network:dbus Can't allocate new method call");
		return;
	}

	dbus_error_init(&err);

	reply = dbus_connection_send_with_reply_and_block(
			dbus_g_connection_get_connection(conn),
			msg, -1, &err);

	dbus_message_unref(msg);

	if (!reply) {
		DEBUG(" network:dbus Can't acquire FD");

		if (dbus_error_is_set(&err)) {
			ERROR("%s", err.message);
			dbus_error_free(&err);
			return;
		}
	}

	if (!dbus_message_get_args(reply, &err,
				   DBUS_TYPE_UNIX_FD, &fd,
				   DBUS_TYPE_INVALID)) {
		DEBUG(" network:dbus Can't get reply arguments");

		if (dbus_error_is_set(&err)) {
			ERROR("%s", err.message);
			dbus_error_free(&err);
			dbus_message_unref(reply);
			return;
		}
	}

	dbus_message_unref(reply);

	// dbus_connection_flush(dbus_g_connection_get_connection(conn));
	DEBUG("File descriptor: %d", fd);

	device_path = dbus_g_proxy_get_path(proxy);
	handle = add_channel(path, device_path, fd, user_data != NULL);

	if (!handle) {
		// channel already known, reconnected
		// or channel is secondary
		return;
	}

	dev = get_device_object(device_path);

	if (dev) {
		device_connected(handle, dev->addr);
	} else {
		ERROR("Channel from unknown device: %s", device_path);
		device_connected(handle, device_path);
	}
}
Пример #29
0
static void
update_device_list (GtkTreeIter *parent)
{
	GtkUIManager *uimanager;
	GtkTreeIter iter;
	gboolean cont;
	guint num_devices;
	GList *actions, *l;

	num_devices = 0;

	uimanager = GTK_UI_MANAGER (gtk_builder_get_object (xml, "bluetooth-applet-ui-manager"));

	if (parent == NULL) {
		/* No default adapter? Remove everything */
		actions = gtk_action_group_list_actions (devices_action_group);
		g_list_foreach (actions, (GFunc) remove_action_item, uimanager);
		g_list_free (actions);
		goto done;
	}

	/* Get a list of actions, and we'll remove the ones with a
	 * device in the list. We remove the submenu items first */
	actions = gtk_action_group_list_actions (devices_action_group);
	for (l = actions; l != NULL; l = l->next) {
		if (bluetooth_verify_address (gtk_action_get_name (l->data)) == FALSE)
			l->data = NULL;
	}
	actions = g_list_remove_all (actions, NULL);

	cont = gtk_tree_model_iter_children (devices_model, &iter, parent);
	while (cont) {
		GHashTable *services;
		DBusGProxy *proxy;
		char *alias, *address, **uuids, *name;
		gboolean is_connected;
		BluetoothType type;
		GtkAction *action, *status, *oper;

		gtk_tree_model_get (devices_model, &iter,
				    BLUETOOTH_COLUMN_PROXY, &proxy,
				    BLUETOOTH_COLUMN_ADDRESS, &address,
				    BLUETOOTH_COLUMN_SERVICES, &services,
				    BLUETOOTH_COLUMN_ALIAS, &alias,
				    BLUETOOTH_COLUMN_UUIDS, &uuids,
				    BLUETOOTH_COLUMN_TYPE, &type,
				    -1);

		if (device_has_submenu ((const char **) uuids, services, type) == FALSE ||
		    address == NULL || proxy == NULL || alias == NULL) {
			if (proxy != NULL)
				g_object_unref (proxy);

			if (services != NULL)
				g_hash_table_unref (services);
			g_strfreev (uuids);
			g_free (alias);
			g_free (address);
			cont = gtk_tree_model_iter_next (devices_model, &iter);
			continue;
		}

		action = gtk_action_group_get_action (devices_action_group, address);
		oper = NULL;
		status = NULL;
		if (action) {
			char *action_name;

			actions = g_list_remove (actions, action);

			action_name = g_strdup_printf ("%s-status", address);
			status = gtk_action_group_get_action (devices_action_group, action_name);
			g_free (action_name);

			action_name = g_strdup_printf ("%s-action", address);
			oper = gtk_action_group_get_action (devices_action_group, action_name);
			g_free (action_name);
		}

		/* If one service is connected, then we're connected */
		is_connected = FALSE;
		if (services != NULL) {
			GList *list, *l;

			list = g_hash_table_get_values (services);
			for (l = list; l != NULL; l = l->next) {
				BluetoothStatus val = GPOINTER_TO_INT (l->data);
				if (val == BLUETOOTH_STATUS_CONNECTED ||
				    val == BLUETOOTH_STATUS_PLAYING) {
					is_connected = TRUE;
					break;
				}
			}
			g_list_free (list);
		}

		name = escape_label_for_action (alias);

		if (action == NULL) {
			guint menu_merge_id;
			char *action_path;

			/* The menu item with descendants */
			action = gtk_action_new (address, name, NULL, NULL);

			gtk_action_group_add_action (devices_action_group, action);
			g_object_unref (action);
			menu_merge_id = gtk_ui_manager_new_merge_id (uimanager);
			gtk_ui_manager_add_ui (uimanager, menu_merge_id,
					       "/bluetooth-applet-popup/devices-placeholder", address, address,
					       GTK_UI_MANAGER_MENU, FALSE);
			g_object_set_data_full (G_OBJECT (action),
						"merge-id", GUINT_TO_POINTER (menu_merge_id), NULL);

			/* The status menu item */
			status = add_menu_item (address,
						"status",
						is_connected ? _("Connected") : _("Disconnected"),
						uimanager,
						menu_merge_id,
						NULL);
			gtk_action_set_sensitive (status, FALSE);

			if (services != NULL) {
				action_path = g_strdup_printf ("/bluetooth-applet-popup/devices-placeholder/%s/%s-status",
							       address, address);
				action_set_bold (uimanager, status, action_path);
				g_free (action_path);
			} else {
				gtk_action_set_visible (status, FALSE);
			}

			/* The connect button */
			oper = add_menu_item (address,
					      "action",
					      is_connected ? _("Disconnect") : _("Connect"),
					      uimanager,
					      menu_merge_id,
					      G_CALLBACK (on_connect_activate));
			if (services == NULL)
				gtk_action_set_visible (oper, FALSE);

			add_separator_item (address, "connect-sep", uimanager, menu_merge_id);

			/* The Send to... button */
			if (device_has_uuid ((const char **) uuids, "OBEXObjectPush") != FALSE) {
				add_menu_item (address,
					       "sendto",
					       _("Send files..."),
					       uimanager,
					       menu_merge_id,
					       G_CALLBACK (sendto_callback));
				g_object_set_data_full (G_OBJECT (action),
							"alias", g_strdup (alias), g_free);
			}
			if (device_has_uuid ((const char **) uuids, "OBEXFileTransfer") != FALSE) {
				add_menu_item (address,
					       "browse",
					       _("Browse files..."),
					       uimanager,
					       menu_merge_id,
					       G_CALLBACK (browse_callback));
			}

			add_separator_item (address, "files-sep", uimanager, menu_merge_id);

			if (type == BLUETOOTH_TYPE_KEYBOARD && program_available (KEYBOARD_PREFS)) {
				add_menu_item (address,
					       "keyboard",
					       _("Open Keyboard Preferences..."),
					       uimanager,
					       menu_merge_id,
					       G_CALLBACK (keyboard_callback));
			}
			if (type == BLUETOOTH_TYPE_MOUSE && program_available (MOUSE_PREFS)) {
				add_menu_item (address,
					       "mouse",
					       _("Open Mouse Preferences..."),
					       uimanager,
					       menu_merge_id,
					       G_CALLBACK (mouse_callback));
			}
			if ((type == BLUETOOTH_TYPE_HEADSET ||
			     type == BLUETOOTH_TYPE_HEADPHONES ||
			     type == BLUETOOTH_TYPE_OTHER_AUDIO) && program_available (SOUND_PREFS)) {
				add_menu_item (address,
					       "sound",
					       _("Open Sound Preferences..."),
					       uimanager,
					       menu_merge_id,
					       G_CALLBACK (sound_callback));
			}
		} else {
			gtk_action_set_label (action, name);

			gtk_action_set_visible (status, services != NULL);
			gtk_action_set_visible (oper, services != NULL);
			if (services != NULL) {
				set_device_status_label (address, is_connected ? CONNECTED : DISCONNECTED);
				gtk_action_set_label (oper, is_connected ? _("Disconnect") : _("Connect"));
			}
		}
		g_free (name);

		if (oper != NULL) {
			g_object_set_data_full (G_OBJECT (oper),
						"connected", GINT_TO_POINTER (is_connected ? CONNECTED : DISCONNECTED), NULL);
			g_object_set_data_full (G_OBJECT (oper),
						"device-path", g_strdup (dbus_g_proxy_get_path (proxy)), g_free);
		}

		/* And now for the trick of the day */
		if (is_connected != FALSE) {
			char *path;

			path = g_strdup_printf ("/bluetooth-applet-popup/devices-placeholder/%s", address);
			action_set_bold (uimanager, action, path);
			g_free (path);
		}

		num_devices++;

		if (proxy != NULL)
			g_object_unref (proxy);

		if (services != NULL)
			g_hash_table_unref (services);
		g_strfreev (uuids);
		g_free (alias);
		g_free (address);
		cont = gtk_tree_model_iter_next (devices_model, &iter);
	}

	/* Remove the left-over devices */
	g_list_foreach (actions, (GFunc) remove_action_item, uimanager);
	g_list_free (actions);

done:
	gtk_ui_manager_ensure_update (uimanager);

	gtk_action_set_visible (GTK_ACTION (gtk_builder_get_object (xml, "devices-label")),
				num_devices > 0);
}
Пример #30
0
static void
modem_get_all_cb (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data)
{
	PluginInfo *info = user_data;
	const char *path;
	GHashTable *properties = NULL;
	GError *error = NULL;
	GValue *value;
	BMDeviceType devtype = BM_DEVICE_TYPE_UNKNOWN;

	path = dbus_g_proxy_get_path (proxy);
	g_message ("%s: (%s) processing GetAll reply", __func__, path);

	if (!dbus_g_proxy_end_call (proxy, call, &error,
	                            DBUS_TYPE_G_MAP_OF_VARIANT, &properties,
	                            G_TYPE_INVALID)) {
		g_warning ("%s: (%s) Error getting modem properties: (%d) %s",
		           __func__,
		           path,
		           error ? error->code : -1,
		           (error && error->message) ? error->message : "(unknown)");
		g_error_free (error);
		goto out;
	}

	/* check whether this is the device we care about */
	value = g_hash_table_lookup (properties, "Device");
	if (value && G_VALUE_HOLDS_STRING (value) && g_value_get_string (value)) {
		char *iface_basename = g_path_get_basename (info->rfcomm_iface);
		const char *modem_iface = g_value_get_string (value);

		if (!strcmp (iface_basename, modem_iface)) {
			/* yay, found it! */

			value = g_hash_table_lookup (properties, "Type");
			if (value && G_VALUE_HOLDS_UINT (value)) {
				switch (g_value_get_uint (value)) {
				case 1:
					devtype = BM_DEVICE_TYPE_GSM;
					break;
				case 2:
					devtype = BM_DEVICE_TYPE_CDMA;
					break;
				default:
					g_message ("%s: (%s) unknown modem type", __func__, path);
					break;
				}
			}
		} else {
			g_message ("%s: (%s) (%s) not the modem we're looking for (%s)",
			           __func__, path, modem_iface, iface_basename);
		}

		g_free (iface_basename);
	} else
		g_message ("%s: (%s) modem had no 'Device' property", __func__, path);

	g_hash_table_unref (properties);

	if (devtype != BM_DEVICE_TYPE_UNKNOWN) {
		GtkWidget *parent;

		if (info->wizard) {
			g_message ("%s: (%s) oops! not starting Wizard as one is already in progress", __func__, path);
			goto out;
		}

		g_message ("%s: (%s) starting the mobile wizard", __func__, path);

		g_source_remove (info->dun_timeout_id);
		info->dun_timeout_id = 0;

		parent = gtk_widget_get_toplevel (info->hbox);
#if GTK_CHECK_VERSION(2,18,0)
		if (gtk_widget_is_toplevel (parent)) {
#else
		if (GTK_WIDGET_TOPLEVEL (parent)) {
#endif
			info->window_group = gtk_window_group_new ();
			gtk_window_group_add_window (info->window_group, GTK_WINDOW (parent));
		} else {
			parent = NULL;
			info->window_group = NULL;
		}

		/* Start the mobile wizard */
		info->wizard = mobile_wizard_new (parent ? GTK_WINDOW (parent) : NULL,
		                                  info->window_group,
		                                  devtype,
		                                  FALSE,
		                                  wizard_done_cb,
		                                  info);
		mobile_wizard_present (info->wizard);
	}

out:
	g_message ("%s: finished", __func__);
}

static void
modem_added (DBusGProxy *proxy, const char *path, gpointer user_data)
{
	PluginInfo *info = user_data;
	DBusGProxy *props_proxy;

	g_return_if_fail (path != NULL);

	g_message ("%s: (%s) modem found", __func__, path);

	/* Create a proxy for the modem and get its properties */
	props_proxy = dbus_g_proxy_new_for_name (info->bus,
	                                         MM_SERVICE,
	                                         path,
	                                         "org.freedesktop.DBus.Properties");
	g_assert (proxy);
	info->modem_proxies = g_slist_append (info->modem_proxies, props_proxy);

	g_message ("%s: (%s) calling GetAll...", __func__, path);

	dbus_g_proxy_begin_call (props_proxy, "GetAll",
	                         modem_get_all_cb,
	                         info,
	                         NULL,
	                         G_TYPE_STRING, MM_MODEM_INTERFACE,
	                         G_TYPE_INVALID);
}