static void
dun_cleanup (PluginInfo *info, const char *message, gboolean uncheck)
{
GSList *iter;
for (iter = info->modem_proxies; iter; iter = g_slist_next (iter))
g_object_unref (DBUS_G_PROXY (iter->data));
g_slist_free (info->modem_proxies);
info->modem_proxies = NULL;
if (info->dun_proxy) {
if (info->rfcomm_iface) {
dbus_g_proxy_call_no_reply (info->dun_proxy, "Disconnect",
G_TYPE_STRING, info->rfcomm_iface,
G_TYPE_INVALID);
}
dbus_g_proxy_disconnect_signal (info->dun_proxy, "PropertyChanged",
G_CALLBACK (dun_property_changed), info);
g_object_unref (info->dun_proxy);
info->dun_proxy = NULL;
}
g_free (info->rfcomm_iface);
info->rfcomm_iface = NULL;
if (info->bus) {
dbus_g_connection_unref (info->bus);
info->bus = NULL;
}
if (info->dun_timeout_id) {
g_source_remove (info->dun_timeout_id);
info->dun_timeout_id = 0;
}
if (info->window_group) {
g_object_unref (info->window_group);
info->window_group = NULL;
}
if (info->wizard) {
mobile_wizard_destroy (info->wizard);
info->wizard = NULL;
}
if (info->spinner) {
nma_bling_spinner_stop (BMA_BLING_SPINNER (info->spinner));
gtk_widget_hide (info->spinner);
}
gtk_label_set_text (GTK_LABEL (info->label), message);
gtk_widget_set_sensitive (info->dun_button, TRUE);
if (uncheck) {
g_signal_handler_block (info->dun_button, info->dun_toggled_id);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (info->dun_button), FALSE);
g_signal_handler_unblock (info->dun_button, info->dun_toggled_id);
}
}
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);
}
}
static gboolean
cancel_all_cb (GObject *object, gpointer call_id, gpointer user_data)
{
dbus_g_proxy_cancel_call (DBUS_G_PROXY (object), (DBusGProxyCall *) call_id);
return TRUE;
}
static void
empathy_account_manager_init (EmpathyAccountManager *manager)
{
EmpathyAccountManagerPriv *priv;
GList *mc_accounts, *l;
AccountData *data;
priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
EMPATHY_TYPE_ACCOUNT_MANAGER, EmpathyAccountManagerPriv);
manager->priv = priv;
priv->monitor = mc_account_monitor_new ();
priv->mc = empathy_mission_control_new ();
priv->connected = priv->connecting = 0;
priv->dispose_run = FALSE;
priv->accounts = g_hash_table_new_full (empathy_account_hash,
empathy_account_equal,
g_object_unref,
(GDestroyNotify) account_data_free);
mc_accounts = mc_accounts_list ();
for (l = mc_accounts; l; l = l->next)
{
data = account_data_new_default (priv->mc, l->data);
account_created_cb (priv->monitor, (char *) mc_account_get_unique_name (l->data), manager);
}
g_signal_connect (priv->monitor, "account-created",
G_CALLBACK (account_created_cb), manager);
g_signal_connect (priv->monitor, "account-deleted",
G_CALLBACK (account_deleted_cb), manager);
g_signal_connect (priv->monitor, "account-disabled",
G_CALLBACK (account_disabled_cb), manager);
g_signal_connect (priv->monitor, "account-enabled",
G_CALLBACK (account_enabled_cb), manager);
g_signal_connect (priv->monitor, "account-changed",
G_CALLBACK (account_changed_cb), manager);
dbus_g_proxy_connect_signal (DBUS_G_PROXY (priv->mc), "AccountStatusChanged",
G_CALLBACK (account_status_changed_cb),
manager, NULL);
mc_accounts_list_free (mc_accounts);
}
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;
}
}
}
ModemRequest *
_modem_request_new (gpointer object,
DBusGProxy *proxy,
GCallback callback,
gpointer user_data)
{
GPtrArray *container = g_ptr_array_sized_new (N_SIZED);
g_ptr_array_set_size (container, N_SIZE);
ModemRequest *request = (gpointer)container;
ModemRequestPrivate *priv = request->priv;
if (object)
priv->object = g_object_ref (object);
priv->proxy = DBUS_G_PROXY (g_object_ref (proxy));
priv->callback = callback;
priv->user_data = user_data;
return request;
}
static void
do_dispose (GObject *obj)
{
EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
if (priv->dispose_run)
return;
priv->dispose_run = TRUE;
dbus_g_proxy_disconnect_signal (DBUS_G_PROXY (priv->mc),
"AccountStatusChanged",
G_CALLBACK (account_status_changed_cb),
obj);
if (priv->monitor)
{
g_signal_handlers_disconnect_by_func (priv->monitor,
account_created_cb, obj);
g_signal_handlers_disconnect_by_func (priv->monitor,
account_deleted_cb, obj);
g_signal_handlers_disconnect_by_func (priv->monitor,
account_disabled_cb, obj);
g_signal_handlers_disconnect_by_func (priv->monitor,
account_enabled_cb, obj);
g_signal_handlers_disconnect_by_func (priv->monitor,
account_changed_cb, obj);
g_object_unref (priv->monitor);
priv->monitor = NULL;
}
if (priv->mc)
g_object_unref (priv->mc);
g_hash_table_remove_all (priv->accounts);
G_OBJECT_CLASS (empathy_account_manager_parent_class)->dispose (obj);
}
static void
auth_session_check_remote_object(SignonAuthSession *self)
{
g_return_if_fail (self != NULL);
SignonAuthSessionPrivate *priv = self->priv;
g_return_if_fail (priv != NULL);
if (priv->proxy != NULL)
return;
g_return_if_fail (priv->signon_proxy != NULL);
if (priv->pending_call_get_path == NULL)
{
priv->pending_call_get_path =
SSO_AuthService_get_auth_session_object_path_async (DBUS_G_PROXY (priv->signon_proxy),
(const guint)priv->id,
priv->method_name,
auth_session_get_object_path_reply,
self);
}
}
static gboolean
auth_session_priv_init (SignonAuthSession *self, guint id,
const gchar *method_name, GError **err)
{
g_return_val_if_fail (SIGNON_IS_AUTH_SESSION (self), FALSE);
SignonAuthSessionPrivate *priv = SIGNON_AUTH_SESSION_PRIV (self);
g_return_val_if_fail (priv, FALSE);
priv->id = id;
priv->method_name = g_strdup (method_name);
priv->pending_call_get_path =
SSO_AuthService_get_auth_session_object_path_async (
DBUS_G_PROXY (priv->signon_proxy),
(const guint)id,
method_name,
auth_session_get_object_path_reply,
self);
priv->busy = FALSE;
priv->canceled = FALSE;
return TRUE;
}
static void
dun_cleanup (NmaBtDevice *self)
{
NmaBtDevicePrivate *priv = NMA_BT_DEVICE_GET_PRIVATE (self);
GSList *iter;
/* ModemManager */
for (iter = priv->modem_proxies; iter; iter = g_slist_next (iter))
g_object_unref (DBUS_G_PROXY (iter->data));
g_slist_free (priv->modem_proxies);
priv->modem_proxies = NULL;
g_clear_object (&priv->mm_proxy);
#if WITH_MODEM_MANAGER_1
g_clear_object (&priv->dbus_connection);
g_clear_object (&priv->modem_manager_1);
#endif
if (priv->dun_proxy && priv->rfcomm_iface) {
dbus_g_proxy_call_no_reply (priv->dun_proxy, "Disconnect",
G_TYPE_STRING, priv->rfcomm_iface,
G_TYPE_INVALID);
}
g_clear_object (&priv->dun_proxy);
g_free (priv->rfcomm_iface);
priv->rfcomm_iface = NULL;
if (priv->dun_timeout_id) {
g_source_remove (priv->dun_timeout_id);
priv->dun_timeout_id = 0;
}
if (priv->wizard) {
nma_mobile_wizard_destroy (priv->wizard);
priv->wizard = NULL;
}
}
static GtkWidget *
get_config_widgets (const char *bdaddr, const char **uuids)
{
WidgetInfo *info;
NmaBtDevice *device;
GtkWidget *vbox, *hbox;
gboolean pan = FALSE, dun = FALSE, busy;
GtkTreeIter iter;
BluetoothClient *btclient;
GtkTreeModel *btmodel;
guint id;
/* Don't allow configuration if NM isn't running; it just confuses people
* if they see the checkboxes but the configuration doesn't seem to have
* any visible effect since they aren't running NM/nm-applet.
*/
if (!nm_is_running ())
return NULL;
get_capabilities (bdaddr, uuids, &pan, &dun);
if (!pan && !dun)
return NULL;
/* BluetoothClient setup */
btclient = bluetooth_client_new ();
btmodel = bluetooth_client_get_model (btclient);
g_assert (btmodel);
device = get_device (bdaddr);
if (!device) {
const char *op = NULL;
gpointer proxy;
char *alias;
if (!get_device_iter (btmodel, bdaddr, &iter)) {
g_warning ("%s: failed to retrieve device %s from gnome-bluetooth!", __func__, bdaddr);
g_object_unref (btmodel);
g_object_unref (btclient);
return NULL;
}
gtk_tree_model_get (btmodel, &iter,
BLUETOOTH_COLUMN_ALIAS, &alias,
BLUETOOTH_COLUMN_PROXY, &proxy,
-1);
g_assert (proxy);
/* At some point gnome-bluetooth switched to gdbus, so we don't know
* if the proxy will be a DBusGProxy (dbus-glib) or a GDBusProxy (gdbus).
*/
if (G_IS_DBUS_PROXY (proxy))
op = g_dbus_proxy_get_object_path (G_DBUS_PROXY (proxy));
else if (DBUS_IS_G_PROXY (proxy))
op = dbus_g_proxy_get_path (DBUS_G_PROXY (proxy));
else
g_assert_not_reached ();
device = nma_bt_device_new (bdaddr, alias, op, pan, dun);
g_free (alias);
g_object_unref (proxy);
if (!device) {
g_warning ("%s: failed to create Bluetooth proxy object!", bdaddr);
g_object_unref (btmodel);
g_object_unref (btclient);
return NULL;
}
add_device (device);
}
info = g_malloc0 (sizeof (WidgetInfo));
info->device = g_object_ref (device);
info->btclient = btclient;
g_signal_connect (G_OBJECT (btclient), "notify::default-adapter",
G_CALLBACK (default_adapter_changed), info);
g_signal_connect (G_OBJECT (btclient), "notify::default-adapter-powered",
G_CALLBACK (default_adapter_powered_changed), info);
id = g_signal_connect (device, "notify::" NMA_BT_DEVICE_PAN_ENABLED,
G_CALLBACK (device_pan_enabled_cb), info);
info->sigids = g_slist_prepend (info->sigids, GUINT_TO_POINTER (id));
id = g_signal_connect (device, "notify::" NMA_BT_DEVICE_DUN_ENABLED,
G_CALLBACK (device_dun_enabled_cb), info);
info->sigids = g_slist_prepend (info->sigids, GUINT_TO_POINTER (id));
id = g_signal_connect (device, "notify::" NMA_BT_DEVICE_BUSY,
G_CALLBACK (device_busy_cb), info);
info->sigids = g_slist_prepend (info->sigids, GUINT_TO_POINTER (id));
id = g_signal_connect (device, "notify::" NMA_BT_DEVICE_STATUS,
G_CALLBACK (device_status_cb), info);
info->sigids = g_slist_prepend (info->sigids, GUINT_TO_POINTER (id));
/* UI setup */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
g_object_set_data_full (G_OBJECT (vbox), "info", info, widget_info_destroy);
busy = nma_bt_device_get_busy (device);
if (pan) {
info->pan_button = gtk_check_button_new_with_label (_("Use your mobile phone as a network device (PAN/NAP)"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (info->pan_button),
nma_bt_device_get_pan_enabled (device));
info->pan_toggled_id = g_signal_connect (G_OBJECT (info->pan_button), "toggled", G_CALLBACK (pan_button_toggled), info);
gtk_box_pack_start (GTK_BOX (vbox), info->pan_button, FALSE, TRUE, 6);
gtk_widget_set_sensitive (info->pan_button, !busy);
}
if (dun) {
info->dun_button = gtk_check_button_new_with_label (_("Access the Internet using your mobile phone (DUN)"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (info->dun_button),
nma_bt_device_get_dun_enabled (device));
info->dun_toggled_id = g_signal_connect (G_OBJECT (info->dun_button), "toggled", G_CALLBACK (dun_button_toggled), info);
gtk_box_pack_start (GTK_BOX (vbox), info->dun_button, FALSE, TRUE, 6);
set_dun_button_sensitive (info, !busy);
}
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 6);
/* Spinner's hbox */
info->hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (hbox), info->hbox, FALSE, FALSE, 0);
device_busy_cb (device, NULL, info);
/* Status label */
info->status = gtk_label_new (nma_bt_device_get_status (device));
gtk_label_set_max_width_chars (GTK_LABEL (info->status), 80);
gtk_label_set_line_wrap (GTK_LABEL (info->status), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), info->status, FALSE, TRUE, 6);
default_adapter_powered_changed (G_OBJECT (info->btclient), NULL, info);
return vbox;
}
static void
auth_session_get_object_path_reply (DBusGProxy *proxy, char *object_path,
GError *error, gpointer userdata)
{
g_return_if_fail (SIGNON_IS_AUTH_SESSION (userdata));
SignonAuthSession *self = SIGNON_AUTH_SESSION (userdata);
SignonAuthSessionPrivate *priv = self->priv;
g_return_if_fail (priv != NULL);
priv->pending_call_get_path = NULL;
if (!g_strcmp0(object_path, "") || error)
{
if (error)
DEBUG ("Error message is %s", error->message);
else {
error = g_error_new (auth_session_errors_quark(), 1, SSO_AUTH_SESSION_CONNECTION_PROBLEM_G);
g_free (object_path);
}
}
else
{
priv->proxy = dbus_g_proxy_new_from_proxy (DBUS_G_PROXY (priv->signon_proxy),
SIGNOND_AUTH_SESSION_INTERFACE,
object_path);
dbus_g_object_register_marshaller (_signon_marshal_VOID__INT_STRING,
G_TYPE_NONE,
G_TYPE_INT,
G_TYPE_STRING,
G_TYPE_INVALID);
dbus_g_proxy_add_signal (priv->proxy,
"stateChanged",
G_TYPE_INT,
G_TYPE_STRING,
G_TYPE_INVALID);
dbus_g_proxy_connect_signal (priv->proxy,
"stateChanged",
G_CALLBACK (auth_session_state_changed_cb),
self,
NULL);
dbus_g_object_register_marshaller (g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
G_TYPE_INVALID);
dbus_g_proxy_add_signal (priv->proxy,
"unregistered",
G_TYPE_INVALID);
dbus_g_proxy_connect_signal (priv->proxy,
"unregistered",
G_CALLBACK (auth_session_remote_object_destroyed_cb),
self,
NULL);
g_free (object_path);
}
DEBUG ("Object path received: %s", object_path);
_signon_object_ready (self, auth_session_object_quark (), error);
g_clear_error (&error);
}
