static void on_proxy_created(GDBusProxy *new_proxy, GAsyncResult *result,
gpointer data)
{
GError *error = NULL;
GDBusProxy *proxy;
GDBusConnection *connection;
proxy = g_dbus_proxy_new_finish(result, &error);
if (!proxy) {
if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
g_warning("Error creating web extension proxy: %s", error->message);
}
g_error_free(error);
/* TODO cancel the dbus connection - use cancelable */
return;
}
connection = g_dbus_proxy_get_connection(proxy);
g_dbus_connection_signal_subscribe(connection, NULL,
VB_WEBEXTENSION_INTERFACE, "PageCreated",
VB_WEBEXTENSION_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
(GDBusSignalCallback)on_web_extension_page_created, proxy,
NULL);
}
static void
proxy_ready_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
UrfDeviceOfono *modem = URF_DEVICE_OFONO (user_data);
UrfDeviceOfonoPrivate *priv = URF_DEVICE_OFONO_GET_PRIVATE (modem);
GError *error = NULL;
priv->proxy = g_dbus_proxy_new_finish (res, &error);
if (!error) {
g_cancellable_reset (priv->cancellable);
g_signal_connect (priv->proxy, "g-signal",
G_CALLBACK (modem_signal_cb), modem);
g_dbus_proxy_call (priv->proxy,
"GetProperties",
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
priv->cancellable,
(GAsyncReadyCallback) get_properties_cb,
modem);
} else {
g_warning ("Could not get oFono Modem proxy: %s",
error ? error->message : "(unknown error)");
}
}
static void
got_session_proxy (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GDBusProxy *proxy;
GError *error = NULL;
proxy = g_dbus_proxy_new_finish (res, &error);
if (proxy == NULL) {
g_debug ("Could not connect to the Session manager: %s", error->message);
g_error_free (error);
} else {
const char *startup_id;
/* Always call this first, as Setenv can only be called before
any client registers */
set_locale (proxy);
/* Register the daemon with gnome-session */
g_signal_connect (G_OBJECT (proxy), "g-signal",
G_CALLBACK (on_session_over), NULL);
startup_id = g_getenv ("DESKTOP_AUTOSTART_ID");
g_dbus_proxy_call (proxy,
"RegisterClient",
g_variant_new ("(ss)", "gnome-settings-daemon", startup_id ? startup_id : ""),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
(GAsyncReadyCallback) on_client_registered,
manager);
}
}
static void
_fcitx_client_create_ic_phase1_finished(GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
FCITX_UNUSED(source_object);
fcitx_gclient_debug("_fcitx_client_create_ic_phase1_finished");
g_return_if_fail (user_data != NULL);
g_return_if_fail (FCITX_IS_CLIENT(user_data));
FcitxClient* self = (FcitxClient*) user_data;
if (self->priv->cancellable) {
g_object_unref (self->priv->cancellable);
self->priv->cancellable = NULL;
}
if (self->priv->improxy)
g_object_unref(self->priv->improxy);
self->priv->improxy = g_dbus_proxy_new_finish(res, NULL);
do {
if (!self->priv->improxy) {
break;
}
gchar* owner_name = g_dbus_proxy_get_name_owner(self->priv->improxy);
if (!owner_name) {
g_object_unref(self->priv->improxy);
self->priv->improxy = NULL;
break;
}
g_free(owner_name);
} while(0);
if (!self->priv->improxy) {
/* unref for create_ic */
g_object_unref(self);
return;
}
self->priv->cancellable = g_cancellable_new ();
char* appname = fcitx_utils_get_process_name();
int pid = getpid();
g_dbus_proxy_call(
self->priv->improxy,
"CreateICv3",
g_variant_new("(si)", appname, pid),
G_DBUS_CALL_FLAGS_NONE,
-1, /* timeout */
self->priv->cancellable,
_fcitx_client_create_ic_cb,
self
);
free(appname);
}
static void connman_manager_proxy_connect_cb(GObject *source, GAsyncResult *res, gpointer user_data)
{
struct ofono_wan_data *od = user_data;
GError *error = 0;
od->connman_manager_proxy = g_dbus_proxy_new_finish(res, &error);
if (error) {
g_warning("Failed to create proxy for connman manager service: %s", error->message);
g_error_free(error);
return;
}
g_message("[WAN] successfully created proxy for connman manager");
g_signal_connect(od->connman_manager_proxy, "g-signal", G_CALLBACK(services_changed_cb), od);
g_dbus_proxy_call(od->connman_manager_proxy, "GetServices", NULL, G_DBUS_CALL_FLAGS_NONE,
-1, NULL, (GAsyncReadyCallback) connman_manager_get_services_cb, od);
}
static void
localed_proxy_ready (GObject *source,
GAsyncResult *res,
gpointer data)
{
GisLanguagePage *self = data;
GisLanguagePagePrivate *priv = gis_language_page_get_instance_private (self);
GDBusProxy *proxy;
GError *error = NULL;
proxy = g_dbus_proxy_new_finish (res, &error);
if (!proxy) {
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
g_warning ("Failed to contact localed: %s\n", error->message);
g_error_free (error);
return;
}
priv->localed = proxy;
}
static void
localed_proxy_ready (GObject *source,
GAsyncResult *res,
GtkBuilder *dialog)
{
GError *error = NULL;
localed_proxy = g_dbus_proxy_new_finish (res, &error);
if (!localed_proxy) {
g_warning ("Failed to contact localed: %s\n", error->message);
g_error_free (error);
return;
}
g_object_weak_ref (G_OBJECT (dialog), (GWeakNotify) g_object_unref, localed_proxy);
g_signal_connect (localed_proxy, "g-properties-changed",
G_CALLBACK (on_localed_properties_changed), dialog);
on_localed_properties_changed (localed_proxy, NULL, NULL, dialog);
}
static void
_fcitx_client_create_ic_phase2_finished(GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
FCITX_UNUSED(source_object);
g_return_if_fail (user_data != NULL);
g_return_if_fail (FCITX_IS_CLIENT(user_data));
FcitxClient* self = (FcitxClient*) user_data;
if (self->priv->cancellable) {
g_object_unref (self->priv->cancellable);
self->priv->cancellable = NULL;
}
if (self->priv->icproxy)
g_object_unref(self->priv->icproxy);
self->priv->icproxy = g_dbus_proxy_new_finish(res, NULL);
do {
if (!self->priv->icproxy)
break;
gchar* owner_name = g_dbus_proxy_get_name_owner(self->priv->icproxy);
if (!owner_name) {
g_object_unref(self->priv->icproxy);
self->priv->icproxy = NULL;
break;
}
g_free(owner_name);
} while(0);
if (self->priv->icproxy) {
g_signal_connect(self->priv->icproxy, "g-signal", G_CALLBACK(_fcitx_client_g_signal), self);
g_signal_emit(user_data, signals[CONNECTED_SIGNAL], 0);
}
/* unref for _fcitx_client_create_ic_cb */
g_object_unref(self);
}
static void
on_poke_proxy (GObject *source_object,
GAsyncResult *result,
gpointer user_data)
{
PokeContext *poke = user_data;
CockpitFakeManager *self = poke->manager;
GError *error = NULL;
GDBusProxy *proxy;
g_assert (poke->outstanding > 0);
poke->outstanding--;
proxy = g_dbus_proxy_new_finish (result, &error);
/* Bail fast if cancelled */
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
{
if (poke->outstanding == 0)
poke_context_finish (self, poke);
return;
}
if (error)
{
g_warning ("Couldn't create proxy: %s", error->message);
g_error_free (error);
}
else
{
g_debug ("fakemanager: proxy created: %s %s", poke->object_path,
g_dbus_proxy_get_interface_name (proxy));
poke->added = g_list_prepend (poke->added, proxy);
}
if (poke->outstanding == 0)
poke_apply_changes_and_finish (self, poke);
}
static void
pk_proxy_created_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GtkAppChooserOnlinePk *self = user_data;
GDBusProxy *proxy;
proxy = g_dbus_proxy_new_finish (result, NULL);
if (proxy == NULL)
{
g_simple_async_result_set_op_res_gboolean (self->priv->init_result, FALSE);
}
else
{
g_simple_async_result_set_op_res_gboolean (self->priv->init_result, TRUE);
self->priv->proxy = proxy;
}
g_simple_async_result_complete (self->priv->init_result);
g_clear_object (&self->priv->init_result);
}
static void
dnsmasq_proxy_cb (GObject *source, GAsyncResult *res, gpointer user_data)
{
NMDnsDnsmasq *self;
NMDnsDnsmasqPrivate *priv;
gs_free_error GError *error = NULL;
gs_free char *owner = NULL;
GDBusProxy *proxy;
proxy = g_dbus_proxy_new_finish (res, &error);
if ( !proxy
&& g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
return;
self = NM_DNS_DNSMASQ (user_data);
if (!proxy) {
_LOGW ("failed to connect to dnsmasq via DBus: %s", error->message);
g_signal_emit_by_name (self, NM_DNS_PLUGIN_FAILED);
return;
}
priv = NM_DNS_DNSMASQ_GET_PRIVATE (self);
priv->dnsmasq = proxy;
nm_clear_g_cancellable (&priv->dnsmasq_cancellable);
_LOGD ("dnsmasq proxy creation successful");
g_signal_connect (priv->dnsmasq, "notify::g-name-owner",
G_CALLBACK (name_owner_changed), self);
owner = g_dbus_proxy_get_name_owner (priv->dnsmasq);
priv->running = (owner != NULL);
if (priv->running)
send_dnsmasq_update (self);
}
static void
got_session_proxy (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GDBusProxy *proxy;
GError *error = NULL;
proxy = g_dbus_proxy_new_finish (res, &error);
if (proxy == NULL) {
g_debug ("Could not connect to the Session manager: %s", error->message);
g_error_free (error);
} else {
/* Always call this first, as Setenv can only be called before
any client registers */
set_locale (proxy);
#ifdef HAVE_IBUS
/* This will register with gnome-session after calling Setenv. */
set_legacy_ibus_env_vars (proxy);
#else
register_with_gnome_session (proxy);
#endif
}
}
MtnConnman *
mtn_connman_new_finish (GAsyncResult *res,
GError **error)
{
return MTN_CONNMAN (g_dbus_proxy_new_finish (res, error));
}
static void
evd_dbus_agent_on_new_dbus_proxy (GObject *obj,
GAsyncResult *res,
gpointer user_data)
{
GSimpleAsyncResult *result;
GDBusProxy *proxy;
GError *error = NULL;
ProxyData *proxy_data;
proxy_data = (ProxyData *) user_data;
result = proxy_data->async_res;
if ( (proxy = g_dbus_proxy_new_finish (res, &error)) != NULL)
{
ObjectData *obj_data;
GDBusProxyFlags flags;
guint *proxy_id;
obj_data = proxy_data->obj_data;
obj_data->proxy_counter++;
proxy_data->proxy_id = obj_data->proxy_counter;
proxy_data->proxy = proxy;
g_hash_table_insert (obj_data->proxies,
&proxy_data->proxy_id,
proxy_data);
proxy_id = g_new (guint, 1);
*proxy_id = obj_data->proxy_counter;
g_simple_async_result_set_op_res_gpointer (result,
proxy_id,
g_free);
flags = g_dbus_proxy_get_flags (proxy);
if ( (flags & G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS) == 0)
{
g_signal_connect (proxy,
"g-signal",
G_CALLBACK (evd_dbus_agent_on_proxy_signal),
proxy_data);
}
if ( (flags & G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES) == 0)
{
g_signal_connect (proxy,
"g-properties-changed",
G_CALLBACK (evd_dbus_agent_on_proxy_properties_changed),
proxy_data);
}
}
else
{
g_simple_async_result_set_from_error (proxy_data->async_res, error);
g_error_free (error);
evd_dbus_agent_free_proxy_data (proxy_data);
}
g_simple_async_result_complete (result);
g_object_unref (result);
}
MtnConnmanService *
mtn_connman_service_new_finish (GAsyncResult *res,
GError **error)
{
return MTN_CONNMAN_SERVICE (g_dbus_proxy_new_finish (res, error));
}
