int
main (int argc,
char *argv[])
{
GDBusConnection *c;
GError *error;
gboolean ret;
error = NULL;
c = g_bus_get_sync (G_BUS_TYPE_SESSION,
NULL, /* GCancellable* */
&error);
g_assert_no_error (error);
error = NULL;
g_dbus_connection_emit_signal (c,
NULL, /* const gchar *destination_bus_name */
"/org/gtk/GDBus/FlushObject",
"org.gtk.GDBus.FlushInterface",
"SomeSignal",
NULL, /* GVariant *parameters */
&error);
g_assert_no_error (error);
error = NULL;
ret = g_dbus_connection_flush_sync (c,
NULL, /* GCancellable* */
&error);
g_assert_no_error (error);
g_assert (ret);
/* and now exit immediately! */
return 0;
}
static GDBusMessage *
screensaver_send_message_void (GDBusConnection *connection,
const char *name,
gboolean expect_reply)
{
GDBusMessage *message, *reply;
GError *error;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (name != NULL, NULL);
message = g_dbus_message_new_method_call (GS_SERVICE,
GS_PATH,
GS_INTERFACE,
name);
if (message == NULL) {
g_warning ("Couldn't allocate the dbus message");
return NULL;
}
error = NULL;
if (! expect_reply) {
reply = NULL;
g_dbus_connection_send_message (connection,
message,
G_DBUS_SEND_MESSAGE_FLAGS_NONE,
NULL,
&error);
} else {
reply = g_dbus_connection_send_message_with_reply_sync (connection,
message,
G_DBUS_SEND_MESSAGE_FLAGS_NONE,
-1,
NULL,
NULL,
&error);
}
if (error != NULL) {
g_warning ("unable to send message: %s", error->message);
g_clear_error (&error);
}
g_dbus_connection_flush_sync (connection, NULL, &error);
if (error != NULL) {
g_warning ("unable to flush message queue: %s", error->message);
g_clear_error (&error);
}
g_object_unref (message);
return reply;
}
static
void
deactivate_dbus_based_screensaver(const char *d_service, const char *d_path,
const char *d_interface)
{
if (!connection)
screensaver_connect();
if (!connection)
return;
if (is_dbus_based_screensaver_active(d_service, d_path, d_interface)) {
// screen saver is active already, deactivating timer makes no sense
return;
}
GDBusMessage *msg = g_dbus_message_new_method_call(d_service, d_path, d_interface,
"SimulateUserActivity");
if (!msg)
return;
GError *error = NULL;
g_dbus_connection_send_message(connection, msg, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, &error);
if (error != NULL) {
trace_error("%s, can't send message, %s\n", __func__, error->message);
g_clear_error(&error);
goto err;
}
// workaround Plasma 5 issue by calling GetSessionIdleTime after SimulateUserActivity
if (config.quirks.plasma5_screensaver) {
msg = g_dbus_message_new_method_call(d_service, d_path, d_interface, "GetSessionIdleTime");
error = NULL;
g_dbus_connection_send_message(connection, msg, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL,
&error);
if (error != NULL) {
trace_error("%s, can't send message, %s\n", __func__, error->message);
g_clear_error(&error);
goto err;
}
}
g_dbus_connection_flush_sync(connection, NULL, &error);
if (error != NULL) {
trace_error("%s, can't flush dbus connection, %s\n", __func__, error->message);
g_clear_error(&error);
goto err;
}
err:
g_object_unref(msg);
}
static
int
is_dbus_based_screensaver_active(const char *d_service, const char *d_path,
const char *d_interface)
{
GDBusMessage *msg = NULL;
GDBusMessage *reply = NULL;
uint32_t ret = 0;
assert(connection);
// detect is screen saver already active
msg = g_dbus_message_new_method_call(d_service, d_path, d_interface, "GetActive");
if (!msg) {
trace_error("%s, can't allocate GDBusMessage\n", __func__);
goto err;
}
GError *error = NULL;
reply = g_dbus_connection_send_message_with_reply_sync(connection, msg,
G_DBUS_SEND_MESSAGE_FLAGS_NONE, -1,
NULL, NULL, &error);
if (error) {
trace_error("%s, can't send message, %s\n", __func__, error->message);
g_clear_error(&error);
goto err;
}
g_dbus_connection_flush_sync(connection, NULL, &error);
if (error != NULL) {
trace_error("%s, can't flush dbus connection, %s\n", __func__, error->message);
g_clear_error(&error);
goto err;
}
GVariant *v = g_dbus_message_get_body(reply);
v = g_variant_get_child_value(v, 0);
if (g_variant_is_of_type(v, G_VARIANT_TYPE_BOOLEAN))
ret = g_variant_get_boolean(v);
else
ret = 0;
err:
if (reply)
g_object_unref(reply);
if (msg)
g_object_unref(msg);
return ret;
}
static void
handle_method_call (GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *method_name,
GVariant *parameters,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
/* Push off the idle timeout */
establish_timeout ();
if (g_strcmp0 (method_name, "Exit") == 0)
{
destroy_windows ();
g_dbus_method_invocation_return_value (invocation, NULL);
g_dbus_connection_flush_sync (connection, NULL, NULL);
gtk_main_quit ();
}
else if (g_strcmp0 (method_name, "CreateWindow") == 0)
{
int width, height;
gboolean alpha, maximized;
g_variant_get (parameters, "(iibb)", &width, &height, &alpha, &maximized);
create_window (width, height, alpha, maximized);
g_dbus_method_invocation_return_value (invocation, NULL);
}
else if (g_strcmp0 (method_name, "WaitWindows") == 0)
{
wait_windows_invocations = g_list_prepend (wait_windows_invocations, invocation);
check_finish_wait_windows ();
}
else if (g_strcmp0 (method_name, "DestroyWindows") == 0)
{
destroy_windows ();
g_dbus_method_invocation_return_value (invocation, NULL);
}
}
int
main (int argc, char *argv[])
{
GDBusConnection *connection;
GError *error = NULL;
nm_g_type_init ();
connection = g_dbus_connection_new_for_address_sync ("unix:path=" NMRUNDIR "/private-dhcp",
G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
NULL, NULL, &error);
if (!connection) {
g_dbus_error_strip_remote_error (error);
g_printerr ("Error: could not connect to NetworkManager D-Bus socket: %s\n",
error->message);
g_error_free (error);
fatal_error ();
}
if (!g_dbus_connection_emit_signal (connection,
NULL,
"/",
NM_DHCP_CLIENT_DBUS_IFACE,
"Event",
build_signal_parameters (),
&error)) {
g_dbus_error_strip_remote_error (error);
g_printerr ("Error: Could not send DHCP Event signal: %s\n", error->message);
g_error_free (error);
fatal_error ();
}
if (!g_dbus_connection_flush_sync (connection, NULL, &error)) {
g_dbus_error_strip_remote_error (error);
g_printerr ("Error: Could not flush D-Bus connection: %s\n", error->message);
g_error_free (error);
fatal_error ();
}
g_object_unref (connection);
return 0;
}
void
g_vfs_job_progress_callback (goffset current_num_bytes,
goffset total_num_bytes,
gpointer user_data)
{
GVfsJobProgress *job = G_VFS_JOB_PROGRESS (user_data);
GVfsJobDBus *dbus_job = G_VFS_JOB_DBUS (job);
g_debug ("g_vfs_job_progress_callback %" G_GOFFSET_FORMAT "/%" G_GOFFSET_FORMAT "\n", current_num_bytes, total_num_bytes);
if (job->callback_obj_path == NULL || job->progress_proxy == NULL)
return;
gvfs_dbus_progress_call_progress (job->progress_proxy,
current_num_bytes,
total_num_bytes,
NULL,
NULL,
NULL);
g_dbus_connection_flush_sync (g_dbus_method_invocation_get_connection (dbus_job->invocation), NULL, NULL);
}
static
uint32_t
detect_dbus_based_screensavers(void)
{
GDBusMessage *msg, *reply;
uint32_t ret;
assert(connection);
// enumerate all services
msg = g_dbus_message_new_method_call("org.freedesktop.DBus", "/org/freedesktop/DBus",
"org.freedesktop.DBus", "ListNames");
if (!msg) {
trace_error("%s, can't allocate GDBusMessage\n", __func__);
ret = 0;
goto err_1;
}
GError *error = NULL;
reply = g_dbus_connection_send_message_with_reply_sync(connection, msg,
G_DBUS_SEND_MESSAGE_FLAGS_NONE, -1,
NULL, NULL, &error);
if (error != NULL) {
trace_error("%s, can't send message, %s\n", __func__, error->message);
g_clear_error(&error);
ret = 0;
goto err_2;
}
g_dbus_connection_flush_sync(connection, NULL, &error);
if (error != NULL) {
trace_error("%s, can't flush dbus connection, %s\n", __func__, error->message);
g_clear_error(&error);
ret = 0;
goto err_3;
}
// iterate over the list
GVariant *v = g_dbus_message_get_body(reply);
GVariantIter *iter;
gchar *str;
uint32_t flags = 0;
g_variant_get(v, "(as)", &iter);
while (g_variant_iter_loop(iter, "s", &str)) {
if (strcmp(str, GS_SERVICE) == 0)
flags |= SST_GNOME_SCREENSAVER;
if (strcmp(str, KS_SERVICE) == 0)
flags |= SST_KDE_SCREENSAVER;
if (strcmp(str, FDOS_SERVICE) == 0)
flags |= SST_FDO_SCREENSAVER;
if (strcmp(str, CINNAMON_SERVICE) == 0)
flags |= SST_CINNAMON_SCREENSAVER;
}
g_variant_iter_free(iter);
ret = flags;
err_3:
g_object_unref(reply);
err_2:
g_object_unref(msg);
err_1:
return ret;
}
int
main (int argc, char **argv)
{
GOptionContext *context;
GError *error = NULL;
GDBusConnection *bus;
GDBusProxy *mpris;
GDBusProxy *queue;
GApplication *app;
gboolean loaded;
gboolean scanned;
GVariant *state;
#ifdef ENABLE_NLS
/* initialize i18n */
bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
/* setup */
setlocale (LC_ALL, "");
g_type_init ();
g_set_prgname ("rhythmbox-client");
/* parse arguments */
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, args, NULL);
g_option_context_parse (context, &argc, &argv, &error);
if (annoy (&error))
exit (1);
rb_debug_init (debug);
app = g_application_new ("org.gnome.Rhythmbox3", G_APPLICATION_IS_LAUNCHER);
if (g_application_register (app, NULL, &error) == FALSE) {
if (check_running) {
rb_debug ("no running instance found");
exit (2);
} else if (quit) {
rb_debug ("no existing instance to quit");
exit (0);
}
rb_debug ("uh.. what?");
exit (0);
}
/* are we just checking if it's running? */
if (check_running) {
rb_debug ("running instance found");
exit (0);
}
/* wait until it's ready to accept control */
state = g_action_group_get_action_state (G_ACTION_GROUP (app), "LoadURI");
if (state == NULL) {
rb_debug ("couldn't get app startup state");
exit (0);
}
bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
g_variant_get (state, "(bb)", &loaded, &scanned);
if ((loaded && scanned) == FALSE) {
GMainLoop *loop;
GDBusProxy *app_proxy;
rb_debug ("waiting for app startup");
loop = g_main_loop_new (NULL, FALSE);
g_signal_connect (app, "action-state-changed", G_CALLBACK (state_changed_cb), loop);
/* dbus implementation of GApplication doesn't do action state updates yet */
app_proxy = g_dbus_proxy_new_sync (bus, G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START, NULL,
"org.gnome.Rhythmbox3",
"/org/gnome/Rhythmbox3",
"org.gtk.Actions",
NULL,
&error);
if (app_proxy == NULL || proxy_has_name_owner (app_proxy) == FALSE) {
g_warning ("unable to wait for app startup: %s", error->message);
g_clear_error (&error);
} else {
g_object_set_data (G_OBJECT (app_proxy), "actual-app", app);
g_signal_connect (app_proxy, "g-signal", G_CALLBACK (state_changed_signal_cb), loop);
g_main_loop_run (loop);
rb_debug ("app is now started enough");
}
}
/* create proxies */
mpris = g_dbus_proxy_new_sync (bus,
G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
NULL,
"org.mpris.MediaPlayer2.rhythmbox",
"/org/mpris/MediaPlayer2",
"org.mpris.MediaPlayer2.Player",
NULL,
&error);
if (mpris == NULL || proxy_has_name_owner (mpris) == FALSE) {
g_warning ("MPRIS D-Bus interface not available, some things won't work");
if (next || previous || (seek != 0) || play || do_pause || play_pause || stop || volume_up || volume_down || (set_volume > -0.01)) {
exit (1);
}
}
queue = g_dbus_proxy_new_sync (bus,
G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
NULL,
"org.gnome.Rhythmbox3",
"/org/gnome/Rhythmbox3/PlayQueue",
"org.gnome.Rhythmbox3.PlayQueue",
NULL,
&error);
if (queue == NULL || proxy_has_name_owner (queue) == FALSE) {
g_warning ("Play queue interface not available, some things won't work");
if (enqueue || clear_queue) {
exit (1);
}
}
/* activate or quit */
if (quit) {
rb_debug ("quitting existing instance");
g_action_group_activate_action (G_ACTION_GROUP (app), "Quit", NULL);
exit (0);
}
/* don't present if we're doing something else */
if (next || previous || (seek != 0) ||
clear_queue ||
play_uri || other_stuff ||
play || do_pause || play_pause || stop || toggle_shuffle ||
print_playing || print_playing_format ||
(set_volume > -0.01) || volume_up || volume_down || print_volume /*|| mute || unmute*/ || (set_rating > -0.01))
no_present = TRUE;
/* present */
if (!no_present) {
g_application_activate (app);
}
/* set song rating */
if (set_rating >= 0.0 && set_rating <= 5.0) {
rb_debug ("rate song");
rate_song (mpris, set_rating);
}
if (toggle_shuffle) {
rb_debug("toggle shuffle");
g_action_group_activate_action (G_ACTION_GROUP (app), "ToggleShuffle", NULL);
annoy(&error);
}
/* skip to next or previous track */
if (next) {
rb_debug ("next track");
g_dbus_proxy_call_sync (mpris, "Next", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
annoy (&error);
} else if (previous) {
rb_debug ("previous track");
g_dbus_proxy_call_sync (mpris, "Previous", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
annoy (&error);
}
/* seek in track */
if (seek != 0) {
GHashTable *properties;
rb_debug ("seek");
properties = get_playing_song_info (mpris);
if (properties != NULL) {
GVariant *v = g_hash_table_lookup (properties, "mpris:trackid");
if (v != NULL) {
g_dbus_proxy_call_sync (mpris,
"SetPosition",
g_variant_new ("(ox)", g_variant_get_string (v, NULL), seek),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
annoy (&error);
}
}
}
/* add/enqueue */
if (clear_queue) {
g_dbus_proxy_call_sync (queue, "ClearQueue", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
annoy (&error);
}
if (other_stuff) {
int i;
for (i = 0; other_stuff[i] != NULL; i++) {
GFile *file;
char *fileuri;
file = g_file_new_for_commandline_arg (other_stuff[i]);
fileuri = g_file_get_uri (file);
if (fileuri == NULL) {
g_warning ("couldn't convert \"%s\" to a URI", other_stuff[i]);
continue;
}
if (enqueue) {
rb_debug ("enqueueing %s", fileuri);
g_dbus_proxy_call_sync (queue, "AddToQueue", g_variant_new ("(s)", fileuri), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
annoy (&error);
} else {
rb_debug ("importing %s", fileuri);
g_action_group_activate_action (G_ACTION_GROUP (app), "LoadURI", g_variant_new ("(sb)", fileuri, FALSE));
}
g_free (fileuri);
g_object_unref (file);
}
}
/* select/activate/play source */
if (select_source) {
rb_debug ("selecting source %s", select_source);
g_action_group_activate_action (G_ACTION_GROUP (app), "ActivateSource", g_variant_new ("(su)", select_source, 0));
} else if (activate_source) {
rb_debug ("activating source %s", activate_source);
g_action_group_activate_action (G_ACTION_GROUP (app), "ActivateSource", g_variant_new ("(su)", activate_source, 1));
} else if (play_source) {
rb_debug ("playing source %s", play_source);
g_action_group_activate_action (G_ACTION_GROUP (app), "ActivateSource", g_variant_new ("(su)", play_source, 2));
}
/* play uri */
if (play_uri) {
GFile *file;
char *fileuri;
file = g_file_new_for_commandline_arg (play_uri);
fileuri = g_file_get_uri (file);
if (fileuri == NULL) {
g_warning ("couldn't convert \"%s\" to a URI", play_uri);
} else {
rb_debug ("loading and playing %s", fileuri);
g_action_group_activate_action (G_ACTION_GROUP (app), "LoadURI", g_variant_new ("(sb)", fileuri, TRUE));
annoy (&error);
}
g_free (fileuri);
g_object_unref (file);
}
/* play/pause/stop */
if (mpris) {
GVariant *v;
gboolean is_playing = FALSE;
v = g_dbus_proxy_get_cached_property (mpris, "PlaybackStatus");
if (v != NULL) {
is_playing = (g_strcmp0 (g_variant_get_string (v, NULL), "Playing") == 0);
g_variant_unref (v);
}
if (play || do_pause || play_pause) {
if (is_playing != play || play_pause) {
rb_debug ("calling PlayPause to change playback state");
g_dbus_proxy_call_sync (mpris, "PlayPause", NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
annoy (&error);
} else {
rb_debug ("no need to change playback state");
}
} else if (stop) {
g_warning ("not implemented yet");
}
}
/* get/set volume, mute/unmute */
if (set_volume > -0.01) {
g_dbus_proxy_call_sync (mpris,
"org.freedesktop.DBus.Properties.Set",
g_variant_new ("(ssv)", "org.mpris.MediaPlayer2.Player", "Volume", g_variant_new_double (set_volume)),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
annoy (&error);
} else if (volume_up || volume_down) {
GVariant *v;
v = g_dbus_proxy_get_cached_property (mpris, "Volume");
if (v != NULL) {
set_volume = g_variant_get_double (v) + (volume_up ? 0.1 : -0.1);
g_dbus_proxy_call_sync (mpris,
"org.freedesktop.DBus.Properties.Set",
g_variant_new ("(ssv)", "org.mpris.MediaPlayer2.Player", "Volume", g_variant_new_double (set_volume)),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
&error);
annoy (&error);
g_variant_unref (v);
}
}
/* no mute for now? */
/*
} else if (unmute || mute) {
org_gnome_Rhythmbox_Player_set_mute (player_proxy, unmute ? FALSE : TRUE, &error);
annoy (&error);
}
*/
if (print_volume) {
gdouble volume = 1.0;
GVariant *v = g_dbus_proxy_get_cached_property (mpris, "Volume");
if (v != NULL) {
volume = g_variant_get_double (v);
g_variant_unref (v);
}
g_print (_("Playback volume is %f.\n"), volume);
}
/* print playing song */
if (print_playing_format) {
print_playing_song (mpris, print_playing_format);
} else if (print_playing) {
print_playing_song_default (mpris);
}
if (mpris) {
g_object_unref (mpris);
}
g_dbus_connection_flush_sync (bus, NULL, NULL);
g_option_context_free (context);
return 0;
}
int
main (int argc, char *argv[])
{
gs_unref_object GDBusConnection *connection = NULL;
gs_free_error GError *error = NULL;
gs_unref_variant GVariant *parameters = NULL;
gs_unref_variant GVariant *result = NULL;
gboolean success = FALSE;
guint try_count = 0;
gint64 time_end;
nm_g_type_init ();
/* FIXME: g_dbus_connection_new_for_address_sync() tries to connect to the socket in
* non-blocking mode, which can easily fail with EAGAIN, causing the creation of the
* socket to fail with "Could not connect: Resource temporarily unavailable".
*
* We should instead create the GIOStream ourself and block on connecting to
* the socket. */
connection = g_dbus_connection_new_for_address_sync ("unix:path=" NMRUNDIR "/private-dhcp",
G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
NULL, NULL, &error);
if (!connection) {
g_dbus_error_strip_remote_error (error);
_LOGE ("could not connect to NetworkManager D-Bus socket: %s",
error->message);
goto out;
}
parameters = build_signal_parameters ();
time_end = g_get_monotonic_time () + (200 * 1000L); /* retry for at most 200 milliseconds */
do_notify:
try_count++;
result = g_dbus_connection_call_sync (connection,
NULL,
NM_DHCP_HELPER_SERVER_OBJECT_PATH,
NM_DHCP_HELPER_SERVER_INTERFACE_NAME,
NM_DHCP_HELPER_SERVER_METHOD_NOTIFY,
parameters,
NULL,
G_DBUS_CALL_FLAGS_NONE,
1000,
NULL,
&error);
if (!result) {
gs_free char *s_err = NULL;
s_err = g_dbus_error_get_remote_error (error);
if (NM_IN_STRSET (s_err, "org.freedesktop.DBus.Error.UnknownMethod")) {
gint64 remaining_time = time_end - g_get_monotonic_time ();
/* I am not sure that a race can actually happen, as we register the object
* on the server side during GDBusServer:new-connection signal.
*
* However, there was also a race for subscribing to an event, so let's just
* do some retry. */
if (remaining_time > 0) {
_LOGi ("failure to call notify: %s (retry %u)", error->message, try_count);
g_usleep (NM_MIN (NM_CLAMP ((gint64) (100L * (1L << try_count)), 5000, 25000), remaining_time));
g_clear_error (&error);
goto do_notify;
}
}
_LOGW ("failure to call notify: %s (try signal via Event)", error->message);
g_clear_error (&error);
/* for backward compatibilty, try to emit the signal. There is no stable
* API between the dhcp-helper and NetworkManager. However, while upgrading
* the NetworkManager package, a newer helper might want to notify an
* older server, which still uses the "Event". */
if (!g_dbus_connection_emit_signal (connection,
NULL,
"/",
NM_DHCP_CLIENT_DBUS_IFACE,
"Event",
parameters,
&error)) {
g_dbus_error_strip_remote_error (error);
_LOGE ("could not send DHCP Event signal: %s", error->message);
goto out;
}
/* We were able to send the asynchronous Event. Consider that a success. */
success = TRUE;
} else
success = TRUE;
if (!g_dbus_connection_flush_sync (connection, NULL, &error)) {
g_dbus_error_strip_remote_error (error);
_LOGE ("could not flush D-Bus connection: %s", error->message);
success = FALSE;
goto out;
}
out:
if (!success)
kill_pid ();
return success ? EXIT_SUCCESS : EXIT_FAILURE;
}
