static void
dnsmasq_update_done (GDBusProxy *proxy, GAsyncResult *res, gpointer user_data)
{
NMDnsDnsmasq *self;
NMDnsDnsmasqPrivate *priv;
gs_free_error GError *error = NULL;
gs_unref_variant GVariant *response = NULL;
response = g_dbus_proxy_call_finish (proxy, res, &error);
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
return;
self = NM_DNS_DNSMASQ (user_data);
priv = NM_DNS_DNSMASQ_GET_PRIVATE (self);
if (!response)
_LOGW ("dnsmasq update failed: %s", error->message);
else {
g_dbus_proxy_call (priv->dnsmasq,
"ClearCache",
NULL,
G_DBUS_CALL_FLAGS_NONE,
-1,
priv->update_cancellable,
(GAsyncReadyCallback) dnsmasq_clear_cache_done,
self);
}
}
static void
on_get_user_id_ready (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GTask *task = G_TASK (user_data);
gpointer *info = g_task_get_source_object (task);
GClueClientInfoPrivate *priv = GCLUE_CLIENT_INFO (info)->priv;
GError *error = NULL;
GVariant *results = NULL;
results = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object),
res,
&error);
if (results == NULL) {
g_task_return_error (task, error);
g_object_unref (task);
return;
}
g_assert (g_variant_n_children (results) > 0);
g_variant_get_child (results, 0, "u", &priv->user_id);
g_variant_unref (results);
g_dbus_proxy_call (priv->dbus_proxy,
"GetConnectionUnixProcessID",
g_variant_new ("(s)", priv->bus_name),
G_DBUS_CALL_FLAGS_NONE,
-1,
g_task_get_cancellable (task),
on_get_pid_ready,
task);
}
static void
_set_property_cb (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
char *key;
GVariant *var;
GError *error;
key = (char *)user_data;
error = NULL;
var = g_dbus_proxy_call_finish (G_DBUS_PROXY (object),
res,
&error);
if (var) {
g_variant_unref (var);
} else if (error) {
g_warning ("Connman Manager.SetProperty() for '%s' failed: %s",
key, error->message);
/* TODO: call a error handler method */
g_error_free (error);
}
g_free (key);
}
static void
on_client_registered (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GVariant *variant;
GError *error = NULL;
gchar *object_path = NULL;
variant = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object), res, &error);
if (error != NULL) {
g_warning ("Unable to register client: %s", error->message);
g_error_free (error);
} else {
g_variant_get (variant, "(o)", &object_path);
g_debug ("Registered client at path %s", object_path);
g_dbus_proxy_new_for_bus (G_BUS_TYPE_SESSION, 0, NULL,
GNOME_SESSION_DBUS_NAME,
object_path,
GNOME_SESSION_CLIENT_PRIVATE_DBUS_INTERFACE,
NULL,
got_client_proxy,
manager);
g_free (object_path);
g_variant_unref (variant);
}
}
static void
iface_check_netreply_cb (GDBusProxy *proxy, GAsyncResult *result, gpointer user_data)
{
NMSupplicantInterface *self;
NMSupplicantInterfacePrivate *priv;
gs_unref_variant GVariant *variant = NULL;
gs_free_error GError *error = NULL;
/* We know NetworkReply is supported if the NetworkReply method returned
* successfully (which is unexpected since we sent a bogus network
* object path) or if we got an "InvalidArgs" (which indicates NetworkReply
* is supported). We know it's not supported if we get an
* "UnknownMethod" error.
*/
variant = g_dbus_proxy_call_finish (proxy, result, &error);
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
return;
self = NM_SUPPLICANT_INTERFACE (user_data);
priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self);
if (variant || _nm_dbus_error_has_name (error, "fi.w1.wpa_supplicant1.InvalidArgs"))
priv->has_credreq = TRUE;
nm_log_dbg (LOGD_SUPPLICANT, "Supplicant %s network credentials requests",
priv->has_credreq ? "supports" : "does not support");
iface_check_ready (self);
}
static void
on_get_unit_file_state_done (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
GetServiceInfoData *data = user_data;
GError *error = NULL;
gs_unref_variant GVariant *result = g_dbus_proxy_call_finish (G_DBUS_PROXY (object), res, &error);
if (error)
{
end_invocation_take_gerror (data->invocation, error);
g_free (data);
return;
}
const gchar *state;
g_variant_get (result, "(&s)", &state);
GVariantBuilder bob;
g_variant_builder_init (&bob, G_VARIANT_TYPE("a{sv}"));
g_variant_builder_add (&bob, "{sv}", "Id", g_variant_new_string (data->name));
g_variant_builder_add (&bob, "{sv}", "IsTemplate", g_variant_new_boolean (TRUE));
g_variant_builder_add (&bob, "{sv}", "UnitFileState", g_variant_new_string (state));
cockpit_services_complete_get_service_info (COCKPIT_SERVICES (data->services), data->invocation,
g_variant_builder_end (&bob));
g_free (data->name);
g_free (data);
}
static void
on_prompt_prompted (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
PerformClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
SecretPrompt *self = SECRET_PROMPT (source);
GError *error = NULL;
GVariant *retval;
retval = g_dbus_proxy_call_finish (G_DBUS_PROXY (self), result, &error);
if (retval)
g_variant_unref (retval);
if (closure->vanished)
g_clear_error (&error);
if (error != NULL) {
g_simple_async_result_take_error (res, error);
perform_prompt_complete (res, TRUE);
} else {
closure->prompting = TRUE;
g_atomic_int_set (&self->pv->prompted, 1);
/* And now we wait for the signal */
}
g_object_unref (res);
}
static void
on_get_client_ready (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GDBusProxy *manager = G_DBUS_PROXY (source_object);
GVariant *results;
const char *client_path;
GError *error = NULL;
results = g_dbus_proxy_call_finish (manager, res, &error);
if (results == NULL) {
g_critical ("Failed to connect to GeoClue2 service: %s", error->message);
exit (-2);
}
g_assert (g_variant_n_children (results) > 0);
g_variant_get_child (results, 0, "&o", &client_path);
g_print ("Client object: %s\n", client_path);
g_dbus_proxy_new_for_bus (G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_NONE,
NULL,
"org.freedesktop.GeoClue2",
client_path,
"org.freedesktop.GeoClue2.Client",
NULL,
on_client_proxy_ready,
manager);
g_variant_unref (results);
}
static gpointer read_characteristic_finish(
GIO_ASYNCSEQ_HANDLE async_seq_handle,
GAsyncResult* result,
GError** error
)
{
READ_CONTEXT* context = (READ_CONTEXT*)GIO_Async_Seq_GetContext(async_seq_handle);
GBytes* result_value;
GVariant* ret = g_dbus_proxy_call_finish(
G_DBUS_PROXY(context->characteristic),
result,
error
);
if (ret != NULL && *error == NULL)
{
result_value = g_variant_get_data_as_bytes(ret);
g_variant_unref(ret);
}
else
{
result_value = NULL;
}
return result_value;
}
static void
on_perm_store_set_done (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
LocationAppStateData *data;
GVariant *results;
GError *error = NULL;
results = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object),
res,
&error);
if (results == NULL)
{
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
g_warning ("Failed to store permissions: %s", error->message);
g_error_free (error);
return;
}
g_variant_unref (results);
data = (LocationAppStateData *) user_data;
data->changing_state = FALSE;
gtk_switch_set_state (GTK_SWITCH (data->widget), data->pending_state);
}
static void
on_perm_store_lookup_done(GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GVariant *ret, *permissions, *permissions_data;
GError *error = NULL;
ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object),
res,
&error);
if (ret == NULL)
{
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
g_warning ("Failed fetch permissions from xdg-app permission store: %s",
error->message);
g_error_free (error);
return;
}
permissions = g_variant_get_child_value (ret, 0);
permissions_data = g_variant_get_child_value (ret, 1);
update_perm_store (user_data, permissions, permissions_data);
g_signal_connect_object (source_object,
"g-signal",
G_CALLBACK (on_perm_store_signal),
user_data,
0);
}
static void
get_brightness_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GError *error = NULL;
GVariant *result;
guint brightness;
GtkRange *range;
CcScreenPanel *self = CC_SCREEN_PANEL (user_data);
result = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object), res, &error);
if (result == NULL)
{
gtk_widget_hide (WID ("screen_brightness_hscale"));
gtk_widget_hide (WID ("screen_auto_reduce_checkbutton"));
gtk_widget_hide (WID ("brightness-frame"));
g_object_set (G_OBJECT (WID ("turn-off-alignment")), "left-padding", 0, NULL);
g_warning ("Error getting brightness: %s", error->message);
g_error_free (error);
return;
}
/* set the slider */
g_variant_get (result,
"(u)",
&brightness);
range = GTK_RANGE (WID ("screen_brightness_hscale"));
gtk_range_set_range (range, 0, 100);
gtk_range_set_increments (range, 1, 10);
gtk_range_set_value (range, brightness);
g_signal_connect (range,
"value-changed",
G_CALLBACK (brightness_slider_value_changed_cb),
user_data);
g_variant_unref (result);
}
static void
packagekit_install_package_names_ready_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
InstallerData *idata = user_data;
GDBusProxy *proxy;
GVariant *values;
GError *error = NULL;
char *message = NULL;
proxy = G_DBUS_PROXY (source_object);
values = g_dbus_proxy_call_finish (proxy, res, &error);
if (values == NULL) {
message = g_strdup_printf ("%s\n%s",
_("There was an internal error trying to search for applications:"),
error->message);
g_clear_error (&error);
}
package_installer_terminated (idata, message);
g_free (message);
if (values != NULL)
g_variant_unref (values);
g_object_unref (proxy);
}
static void
_get_properties_for_passphrase_cb (GObject *obj,
GAsyncResult *res,
gpointer user_data)
{
MtnConnmanService *service;
GError *error;
GVariant *var;
service = MTN_CONNMAN_SERVICE (obj);
error = NULL;
var = g_dbus_proxy_call_finish (G_DBUS_PROXY (obj), res, &error);
if (!var) {
g_warning ("Connman Service.GetProperties failed: %s",
error->message);
g_error_free (error);
} else {
GVariant *value;
char *key;
GVariantIter *iter;
g_variant_get (var, "(a{sv})", &iter);
while (g_variant_iter_next (iter, "{sv}", &key, &value)) {
if (g_strcmp0 (key, "Passphrase") == 0 ||
g_strcmp0 (key, "PassphraseRequired") == 0) {
mtn_connman_service_handle_new_property (service,
key, value);
}
}
g_variant_iter_free (iter);
g_variant_unref (var);
}
}
static void
got_users (GObject *object,
GAsyncResult *res,
gpointer data)
{
UmUserManager *manager = data;
GVariant *result;
GError *error = NULL;
result = g_dbus_proxy_call_finish (G_DBUS_PROXY (object), res, &error);
if (!result) {
manager->no_service = TRUE;
g_error_free (error);
goto done;
}
if (g_variant_is_of_type (result, G_VARIANT_TYPE ("(ao)"))) {
GVariantIter *iter;
gchar *object_path;
g_variant_get (result, "(ao)", &iter);
while (g_variant_iter_loop (iter, "&o", &object_path))
user_added_handler (manager, object_path);
g_variant_iter_free (iter);
}
g_variant_unref (result);
done:
g_signal_emit (G_OBJECT (manager), signals[USERS_LOADED], 0);
}
static void
on_service_open_session_plain (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
OpenSessionClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
SecretService *service = SECRET_SERVICE (source);
GError *error = NULL;
GVariant *response;
response = g_dbus_proxy_call_finish (G_DBUS_PROXY (service), result, &error);
/* A successful response, decode it */
if (response != NULL) {
if (response_open_session_plain (closure->session, response)) {
_secret_service_take_session (service, closure->session);
closure->session = NULL;
} else {
g_simple_async_result_set_error (res, SECRET_ERROR, SECRET_ERROR_PROTOCOL,
_("Couldn’t communicate with the secret storage"));
}
g_simple_async_result_complete (res);
g_variant_unref (response);
} else {
g_simple_async_result_take_error (res, error);
g_simple_async_result_complete (res);
}
g_object_unref (res);
}
static void
on_list_units_done (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
ListServicesData *data = user_data;
GError *error = NULL;
data->units = g_dbus_proxy_call_finish (G_DBUS_PROXY (object), res, &error);
if (error)
{
end_invocation_take_gerror (data->invocation, error);
g_free (data);
return;
}
g_dbus_proxy_call (data->services->systemd,
"ListUnitFiles",
NULL,
G_DBUS_CALL_FLAGS_NONE,
G_MAXINT,
NULL,
on_list_files_done,
data);
}
static void
first_call_complete(GObject *proxy, GAsyncResult *res, XmrMMKeysPlugin *plugin)
{
GVariant *result;
GError *error = NULL;
result = g_dbus_proxy_call_finish(G_DBUS_PROXY(proxy), res, &error);
if (error != NULL)
{
xmr_debug("Unable to grab media player keys: %s", error->message);
g_clear_error(&error);
#ifdef HAVE_MMKEYS_H
mmkeys_grab(plugin, TRUE);
plugin->grab_type = X_KEY_GRAB;
#endif
return;
}
g_signal_connect_object(plugin->proxy, "g-signal", G_CALLBACK(media_player_key_pressed), plugin, 0);
/* re-grab keys when the main window gains focus */
g_signal_connect_object(plugin->window, "focus-in-event",
G_CALLBACK(window_focus_cb),
plugin, 0);
g_variant_unref(result);
}
static void get_capabilities_callback(GObject* source, GAsyncResult* res, gpointer user_data UNUSED)
{
char** caps;
GVariant* result;
result = g_dbus_proxy_call_finish(G_DBUS_PROXY(source), res, NULL);
if (result == NULL || !g_variant_is_of_type(result, G_VARIANT_TYPE("(as)")))
{
if (result != NULL)
{
g_variant_unref(result);
}
return;
}
g_variant_get(result, "(^a&s)", &caps);
for (int i = 0; caps[i] != NULL; i++)
{
if (g_strcmp0(caps[i], "actions") == 0)
{
server_supports_actions = TRUE;
break;
}
}
g_free(caps);
g_variant_unref(result);
}
static void
first_call_complete (GObject *proxy, GAsyncResult *res, RBMMKeysPlugin *plugin)
{
GVariant *result;
GError *error = NULL;
GtkWindow *window;
result = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, &error);
if (error != NULL) {
g_warning ("Unable to grab media player keys: %s", error->message);
g_clear_error (&error);
#ifdef HAVE_MMKEYS
if (GDK_IS_X11_DISPLAY (gdk_display_get_default ())) {
mmkeys_grab (plugin, TRUE);
plugin->grab_type = X_KEY_GRAB;
}
#endif
return;
}
rb_debug ("grabbed media player keys");
g_signal_connect_object (plugin->proxy, "g-signal", G_CALLBACK (media_player_key_pressed), plugin, 0);
/* re-grab keys when the main window gains focus */
g_object_get (plugin->shell, "window", &window, NULL);
g_signal_connect_object (window, "focus-in-event",
G_CALLBACK (window_focus_cb),
plugin, 0);
g_object_unref (window);
g_variant_unref (result);
}
static void
on_prompt_dismissed (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
PerformClosure *closure = g_simple_async_result_get_op_res_gpointer (res);
SecretPrompt *self = SECRET_PROMPT (source);
GError *error = NULL;
GVariant *retval;
retval = g_dbus_proxy_call_finish (G_DBUS_PROXY (self), result, &error);
if (retval)
g_variant_unref (retval);
if (closure->vanished)
g_clear_error (&error);
if (g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD))
g_clear_error (&error);
if (error != NULL) {
g_simple_async_result_take_error (res, error);
perform_prompt_complete (res, TRUE);
}
g_object_unref (res);
}
static void
on_discover_done (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
struct DiscoverData *data = (struct DiscoverData *)user_data;
GError *error = NULL;
gs_unref_variant GVariant *discover_result = g_dbus_proxy_call_finish (G_DBUS_PROXY (object), res, &error);
if (error)
{
g_dbus_error_strip_remote_error (error);
g_dbus_method_invocation_return_error (data->invocation,
COCKPIT_ERROR, COCKPIT_ERROR_FAILED,
"%s", error->message);
g_free (data);
g_error_free (error);
return;
}
g_variant_builder_init (&(data->all_details), G_VARIANT_TYPE ("aa{sv}"));
g_variant_get (discover_result, "(iao)", NULL, &(data->object_paths));
data->cur_proxy = NULL;
get_next_discover_info (data);
}
static void
set_ap_scan_cb (GDBusProxy *proxy, GAsyncResult *result, gpointer user_data)
{
NMSupplicantInterface *self;
NMSupplicantInterfacePrivate *priv;
gs_unref_variant GVariant *reply = NULL;
gs_free_error GError *error = NULL;
reply = g_dbus_proxy_call_finish (proxy, result, &error);
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
return;
self = NM_SUPPLICANT_INTERFACE (user_data);
priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self);
if (!reply) {
g_dbus_error_strip_remote_error (error);
nm_log_warn (LOGD_SUPPLICANT, "Couldn't send AP scan mode to the supplicant interface: %s.",
error->message);
emit_error_helper (self, error);
return;
}
nm_log_info (LOGD_SUPPLICANT, "Config: set interface ap_scan to %d",
nm_supplicant_config_get_ap_scan (priv->cfg));
g_dbus_proxy_call (priv->iface_proxy,
"AddNetwork",
g_variant_new ("(@a{sv})", nm_supplicant_config_to_variant (priv->cfg)),
G_DBUS_CALL_FLAGS_NONE,
-1,
priv->assoc_cancellable,
(GAsyncReadyCallback) add_network_cb,
self);
}
static void
is_active_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
gboolean active = FALSE;
GError *error = NULL;
GVariant *result;
GnomeSettingsSession *session = GNOME_SETTINGS_SESSION (user_data);
/* is our session active */
result = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object),
res,
&error);
if (result == NULL) {
g_warning ("IsActive failed: %s", error->message);
g_error_free (error);
return;
}
g_variant_get (result, "(b)", &active);
gnome_settings_session_set_state (session, active);
/* watch for changes */
g_signal_connect (session->priv->proxy_session, "g-signal",
G_CALLBACK (gnome_settings_session_proxy_signal_cb),
session);
g_variant_unref (result);
}
static void finish_auth_check(GObject *source_object, GAsyncResult *res, gpointer user_data) {
GError *error = NULL;
GVariant *result;
gboolean authorized;
struct auth_check *auth_check = user_data;
if (auth_check->cancel_id)
g_source_remove(auth_check->cancel_id);
g_free(auth_check->cancel_string);
result = g_dbus_proxy_call_finish(polkit_proxy, res, &error);
if (!result) {
g_dbus_error_strip_remote_error(error);
g_printerr("Failed to check authorization: %s\n", error->message);
g_error_free(error);
authorized = FALSE;
} else {
g_variant_get(result, "((bba{ss}))", &authorized, NULL, NULL);
g_variant_unref(result);
}
if (authorized) {
(auth_check->handler)(auth_check->invocation, auth_check->handler_data);
} else {
return_error(auth_check->invocation, G_DBUS_ERROR_AUTH_FAILED, "Not authorized");
}
g_object_unref(auth_check->cancellable);
g_free(auth_check->handler_data);
g_free(auth_check);
g_assert(running_auth_checks);
running_auth_checks--;
}
static void
got_session_path_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
GVariant *result;
GError *error = NULL;
GnomeSettingsSession *session = GNOME_SETTINGS_SESSION (user_data);
result = g_dbus_proxy_call_finish (G_DBUS_PROXY (source_object),
res,
&error);
if (result == NULL) {
g_warning ("Failed to get session for pid: %s",
error->message);
g_error_free (error);
return;
}
g_variant_get (result, "(o)", &session->priv->session_id);
g_debug ("ConsoleKit session ID: %s", session->priv->session_id);
/* connect to session */
g_dbus_proxy_new_for_bus (G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
NULL,
CONSOLEKIT_NAME,
session->priv->session_id,
CONSOLEKIT_SESSION_INTERFACE,
session->priv->cancellable,
got_session_proxy_cb,
session);
g_variant_unref (result);
}
static void
_get_services_cb (GObject *obj,
GAsyncResult *res,
gpointer user_data)
{
MtnConnman *connman;
GError *error;
GVariant *var;
InitData *data;
connman = MTN_CONNMAN (obj);
data = (InitData*)user_data;
error = NULL;
var = g_dbus_proxy_call_finish (G_DBUS_PROXY (obj), res, &error);
if (!var) {
g_warning ("Initial GetServices() failed: %s\n",
error->message);
g_error_free (error);
} else {
connman->priv->services = var;
}
if (data->done_props) {
g_simple_async_result_complete_in_idle (data->res);
g_object_unref (data->res);
g_free (data);
} else {
data->done_services = TRUE;
}
}
static void
print_file_done (GObject *source,
GAsyncResult *result,
gpointer data)
{
GtkPrintOperation *op = data;
GtkPrintOperationPortal *op_portal = op->priv->platform_data;
GError *error = NULL;
GVariant *ret;
ret = g_dbus_proxy_call_finish (op_portal->proxy,
result,
&error);
if (ret == NULL)
{
if (op->priv->error == NULL)
op->priv->error = g_error_copy (error);
g_warning ("Print file failed: %s", error->message);
g_error_free (error);
}
else
g_variant_unref (ret);
if (op_portal->loop)
g_main_loop_quit (op_portal->loop);
g_object_unref (op);
}
static void
install_mime_types_ready_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GtkAppChooserOnlinePk *self = user_data;
GDBusProxy *proxy = G_DBUS_PROXY (source);
GError *error = NULL;
GVariant *variant;
variant = g_dbus_proxy_call_finish (proxy, res, &error);
if (variant == NULL)
{
/* don't show errors if the user cancelled the installation explicitely
* or if PK wasn't able to find any apps
*/
if (g_strcmp0 (g_dbus_error_get_remote_error (error), "org.freedesktop.PackageKit.Modify.Cancelled") != 0 &&
g_strcmp0 (g_dbus_error_get_remote_error (error), "org.freedesktop.PackageKit.Modify.NoPackagesFound") != 0)
g_simple_async_result_set_from_error (self->priv->result, error);
g_error_free (error);
}
g_simple_async_result_complete (self->priv->result);
g_clear_object (&self->priv->result);
}
static void
keys_grab_complete_cb (GObject *proxy,
GAsyncResult *result,
MexMMkeys *self)
{
MexMMkeysPrivate *priv = MEX_MMKEYS (self)->priv;
GError *error = NULL;
g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), result, &error);
if (error)
{
g_warning ("media player keys not available: %s", error->message);
g_clear_error (&error);
}
else
{
priv->key_grab_active = TRUE;
g_signal_connect_object (priv->proxy,
"g-signal",
G_CALLBACK (mm_keys_pressed),
self, 0);
}
}
