static void
_check_if_seeked (ClutterMedia *media,
GParamSpec *pspec,
MexMprisPlugin *self)
{
MexMprisPluginPrivate *priv = MEX_MPRIS_PLUGIN (self)->priv;
if (clutter_gst_player_get_in_seek (CLUTTER_GST_PLAYER (media)))
{
gdouble progress, duration;
gint64 newposition;
duration = clutter_media_get_duration (media);
/* progress is in a range of 0.0 1.0 so convert to position in uS */
progress = clutter_media_get_progress (media);
newposition = duration * progress * 1000000;
g_dbus_connection_emit_signal (priv->connection,
NULL, MPRIS_OBJECT_NAME,
MPRIS_PLAYER_INTERFACE, "Seeked",
g_variant_new ("(x)", newposition),
NULL);
}
}
static void
child_watch_died (GPid pid,
gint status,
gpointer user_data)
{
PidData *pid_data = user_data;
g_autoptr(GVariant) signal_variant = NULL;
g_debug ("Client Pid %d died", pid_data->pid);
signal_variant = g_variant_ref_sink (g_variant_new ("(uu)", pid, status));
g_dbus_connection_emit_signal (session_bus,
pid_data->client,
"/org/freedesktop/portal/Flatpak",
"org.freedesktop.portal.Flatpak",
"SpawnExited",
signal_variant,
NULL);
/* This frees the pid_data, so be careful */
g_hash_table_remove (client_pid_data_hash, GUINT_TO_POINTER (pid_data->pid));
/* This might have caused us to go to idle (zero children) */
schedule_idle_callback ();
}
void send_ready()
{
GError* err = NULL;
GDBusConnection* conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &err);
if (err != NULL) {
g_warning("get session bus failed:%s", err->message);
g_clear_error(&err);
return;
}
g_dbus_connection_emit_signal(conn,
NULL,
"/com/deepin/dde/screenlock/Frontend",
"com.deepin.dde.screenlock.Frontend",
"Ready",
NULL,
&err);
g_object_unref(conn);
if (err != NULL) {
g_warning("send_readyfailed: %s", err->message);
g_clear_error(&err);
}
}
static void
g_dbus_object_manager_server_emit_interfaces_removed (GDBusObjectManagerServer *manager,
RegistrationData *data,
const gchar *const *interfaces)
{
GVariantBuilder array_builder;
GError *error;
guint n;
const gchar *object_path;
if (data->manager->priv->connection == NULL)
goto out;
g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("as"));
for (n = 0; interfaces[n] != NULL; n++)
g_variant_builder_add (&array_builder, "s", interfaces[n]);
error = NULL;
object_path = g_dbus_object_get_object_path (G_DBUS_OBJECT (data->object));
g_dbus_connection_emit_signal (data->manager->priv->connection,
NULL, /* destination_bus_name */
manager->priv->object_path,
manager_interface_info.name,
"InterfacesRemoved",
g_variant_new ("(oas)",
object_path,
&array_builder),
&error);
g_assert_no_error (error);
out:
;
}
static void
do_refresh (NAApplication *application)
{
struct timeval t;
gettimeofday (&t, NULL);
GList *proc_info = na_process_info_get_all (t);
if (proc_info == NULL)
return;
GVariantBuilder *builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
while (proc_info != NULL)
{
NAProcInfo *info = (NAProcInfo *)proc_info->data;
g_variant_builder_add (builder, "(sidd)", info->name, info->pid, tokbps (info->recv), tokbps (info->sent));
proc_info = proc_info->next;
}
g_debug ("DBUS: Emitting signal on system bus");
g_dbus_connection_emit_signal (na_application_get_system_bus (application),
NULL,
NETWORK_ANALYZER_DBUS_OBJECT_PATH,
NETWORK_ANALYZER_DBUS_IFACE,
"UsageChanged",
g_variant_new ("(a(sidd))", builder),
NULL);
g_variant_builder_unref (builder);
}
/* Send the terminate signal */
void service_terminate(struct service *service)
{
GError *error=NULL;
g_dbus_connection_emit_signal(service->connection, NULL, "/org/florence/Keyboard",
"org.florence.Keyboard", "terminate", NULL, &error);
if (error) flo_error(_("Error emitting terminate signal: %s"), error->message);
}
/**
* send_properites_changed
**/
static void
emit_properites_changed (UrfKillswitch *killswitch)
{
UrfKillswitchPrivate *priv = killswitch->priv;
GVariantBuilder *builder;
GError *error = NULL;
builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
g_variant_builder_add (builder,
"{sv}",
"state",
g_variant_new_int32 (priv->state));
g_dbus_connection_emit_signal (priv->connection,
NULL,
priv->object_path,
"org.freedesktop.DBus.Properties",
"PropertiesChanged",
g_variant_new ("(sa{sv}as)",
URF_KILLSWITCH_INTERFACE,
builder,
NULL),
&error);
if (error) {
g_warning ("Failed to emit PropertiesChanged: %s", error->message);
g_error_free (error);
}
}
/**
* @brief Perform sending remote signals to connected clients.
* @memberof GstSwitchController
*/
static void
gst_switch_controller_emit_signal (GstSwitchController * controller,
const gchar * signame, GVariant * parameters)
{
GError *error;
gboolean res;
GList *client;
gint num;
GST_SWITCH_CONTROLLER_LOCK_CLIENTS (controller);
g_assert (parameters);
g_variant_ref_sink (parameters);
for (client = controller->clients, num = 0; client;
client = g_list_next (client)) {
error = NULL;
res = g_dbus_connection_emit_signal (G_DBUS_CONNECTION (client->data),
/*destination_bus_name */ NULL,
SWITCH_CONTROLLER_OBJECT_PATH,
SWITCH_CONTROLLER_OBJECT_NAME, signame, parameters, &error);
if (!res) {
g_assert (error != NULL);
ERROR ("emit: (%d) %s", num, error->message);
} else {
++num;
}
}
/*
INFO ("emit: %s (%d/%d)", signame, num, g_list_length (controller->uis));
*/
g_variant_unref (parameters);
GST_SWITCH_CONTROLLER_UNLOCK_CLIENTS (controller);
}
static void
on_appointment_sources_changed (CalendarSources *sources,
gpointer user_data)
{
App *app = user_data;
print_debug ("Sources changed\n");
app_load_events (app);
/* Notify the HasCalendars property */
{
GVariantBuilder dict_builder;
g_variant_builder_init (&dict_builder, G_VARIANT_TYPE ("a{sv}"));
g_variant_builder_add (&dict_builder, "{sv}", "HasCalendars",
g_variant_new_boolean (app_has_calendars (app)));
g_dbus_connection_emit_signal (g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL),
NULL,
"/org/gnome/Shell/CalendarServer",
"org.freedesktop.DBus.Properties",
"PropertiesChanged",
g_variant_new ("(sa{sv}as)",
"org.gnome.Shell.CalendarServer",
&dict_builder,
NULL),
NULL);
}
}
/**
* cd_sensor_dbus_emit_property_changed:
**/
static void
cd_sensor_dbus_emit_property_changed (CdSensor *sensor,
const gchar *property_name,
GVariant *property_value)
{
GVariantBuilder builder;
GVariantBuilder invalidated_builder;
/* not yet connected */
if (sensor->priv->connection == NULL)
return;
/* build the dict */
g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
g_variant_builder_init (&builder, G_VARIANT_TYPE_ARRAY);
g_variant_builder_add (&builder,
"{sv}",
property_name,
property_value);
g_debug ("CdSensor: emit PropertiesChanged(%s)", property_name);
g_dbus_connection_emit_signal (sensor->priv->connection,
NULL,
sensor->priv->object_path,
"org.freedesktop.DBus.Properties",
"PropertiesChanged",
g_variant_new ("(sa{sv}as)",
COLORD_DBUS_INTERFACE_SENSOR,
&builder,
&invalidated_builder),
NULL);
}
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 void hev_dbus_object_test_notify_value_handler(GObject *obj,
GParamSpec *pspec, gpointer user_data)
{
HevDBusInterfaceTest *self = HEV_DBUS_INTERFACE_TEST(user_data);
HevDBusInterfaceTestPrivate *priv = HEV_DBUS_INTERFACE_TEST_GET_PRIVATE(self);
GDBusConnection *connection = NULL;
const gchar *object_path = NULL;
GVariantBuilder *builder = NULL;
GVariant *variant = NULL;
gchar *p = NULL;
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
connection = g_dbus_interface_skeleton_get_connection(G_DBUS_INTERFACE_SKELETON(self));
object_path = g_dbus_interface_skeleton_get_object_path(G_DBUS_INTERFACE_SKELETON(self));
builder = g_variant_builder_new(G_VARIANT_TYPE_VARDICT);
g_object_get(obj, "value", &p, NULL);
g_variant_builder_add(builder, "{sv}", "Value", g_variant_new_string(p));
variant = g_variant_builder_end(builder);
g_variant_builder_unref(builder);
variant = g_variant_new("(@a{sv})", variant);
g_free(p);
g_dbus_connection_emit_signal(connection, NULL, object_path,
"org.freedesktop.DBus.Properties", "PropertiesChanged",
variant, NULL);
g_variant_unref(variant);
}
/**
* urf_killswitch_state_refresh:
**/
static void
urf_killswitch_state_refresh (UrfKillswitch *killswitch)
{
UrfKillswitchPrivate *priv = killswitch->priv;
KillswitchState platform;
KillswitchState new_state;
gboolean platform_checked = FALSE;
UrfDevice *device;
GList *iter;
GError *error = NULL;
if (priv->devices == NULL) {
priv->state = KILLSWITCH_STATE_NO_ADAPTER;
priv->saved_state = KILLSWITCH_STATE_NO_ADAPTER;
return;
}
platform = KILLSWITCH_STATE_NO_ADAPTER;
new_state = KILLSWITCH_STATE_NO_ADAPTER;
for (iter = priv->devices; iter; iter = iter->next) {
KillswitchState state;
device = (UrfDevice *)iter->data;
state = urf_device_get_state (device);
if (urf_device_is_platform (device) == TRUE) {
/* Update the state of platform switch */
platform_checked = TRUE;
if (state > platform)
platform = state;
} else {
/* Update the state of non-platform switch */
if (state > new_state)
new_state = state;
}
}
if (platform_checked)
new_state = aggregate_states (platform, new_state);
g_message("killswitch state: %s new_state: %s",
state_to_string(priv->state), state_to_string(new_state));
/* emit a signal for change */
if (priv->state != new_state) {
priv->state = new_state;
emit_properites_changed (killswitch);
g_dbus_connection_emit_signal (priv->connection,
NULL,
priv->object_path,
URF_KILLSWITCH_INTERFACE,
"StateChanged",
NULL,
&error);
if (error) {
g_warning ("Failed to emit StateChanged: %s",
error->message);
g_error_free (error);
}
}
}
static void
timer_handler (int sig,
siginfo_t *si,
void *uc)
{
if (connect != NULL && si->si_value.sival_ptr == &timerid)
{
bool status;
if (read_keyboard_status (&status) && keyboardEnabled != status)
{
keyboardEnabled = status;
GVariantBuilder props_builder;
GVariant *props_changed = NULL;
g_variant_builder_init (&props_builder, G_VARIANT_TYPE ("a{sv}"));
g_variant_builder_add (&props_builder, "{sv}", "LaptopMode",
g_variant_new_boolean (keyboardEnabled));
props_changed= g_variant_new ("(s@a{sv}@as)",
KEYBOARDBUS ,
g_variant_builder_end(&props_builder),
g_variant_new_strv (NULL, 0));
g_dbus_connection_emit_signal (connect,
NULL,
KEYBOARDPATH,
"org.freedesktop.DBus.Properties",
"PropertiesChanged",
props_changed, NULL);
keyboard__set_laptop_mode (exported_key_object, status);
}
}
}
static gboolean handle_set_property (GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *property_name,
GVariant *value,
GError **error,
gpointer user_data)
{
printf("set property: '%s'\n", property_name);
if (!g_strcmp0(property_name, "Title")) {
if (g_strcmp0(_global_title, g_variant_get_string (value, NULL))) {
GVariantBuilder *builder;
GError *local_error;
g_free(_global_title);
_global_title = g_variant_dup_string(value, NULL);
local_error = NULL;
builder = g_variant_builder_new(G_VARIANT_TYPE_ARRAY);
g_variant_builder_add
(builder, "{sv}", "Title",
g_variant_new_string(_global_title));
g_dbus_connection_emit_signal
(connection, NULL, object_path,
"org.freedesktop.DBus.Properties",
"PropertiesChanged",
g_variant_new("(sa{sv}as)", interface_name,
builder, NULL),
&local_error);
g_assert_no_error (local_error);
}
}
return *error == NULL;
}
static gboolean
emit_notifications_in_idle (gpointer user_data)
{
GObject *object = G_OBJECT (user_data);
GDBusConnection *connection;
const gchar *path;
GHashTable *notification_queue;
GHashTableIter iter;
const gchar *property_name;
GVariant *value;
GVariantBuilder *builder;
GVariantBuilder *invalidated_builder;
GHashTable *pvc;
gboolean has_changes;
notification_queue = g_object_get_data (object, "gdbus-codegen-notification-queue");
path = g_object_get_data (object, "gdbus-codegen-path");
connection = g_object_get_data (object, "gdbus-codegen-connection");
pvc = g_object_get_data (object, "gdbus-codegen-pvc");
g_assert (notification_queue != NULL && path != NULL && connection != NULL && pvc != NULL);
builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
invalidated_builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
g_hash_table_iter_init (&iter, notification_queue);
has_changes = FALSE;
while (g_hash_table_iter_next (&iter, (gpointer) &property_name, (gpointer) &value))
{
GVariant *cached_value;
cached_value = g_hash_table_lookup (pvc, property_name);
if (cached_value == NULL || !g_variant_equal (cached_value, value))
{
g_hash_table_insert (pvc, (gpointer) property_name, (gpointer) g_variant_ref (value));
g_variant_builder_add (builder, "{sv}", property_name, value);
has_changes = TRUE;
}
}
if (has_changes)
{
g_dbus_connection_emit_signal (connection,
NULL,
path,
"org.freedesktop.DBus.Properties",
"PropertiesChanged",
g_variant_new ("(sa{sv}as)",
"org.gnome.evolution.dataserver.CalendarFactory",
builder,
invalidated_builder),
NULL);
}
else
{
g_variant_builder_unref (builder);
g_variant_builder_unref (invalidated_builder);
}
g_hash_table_remove_all (notification_queue);
g_object_set_data (object, "gdbus-codegen-notification-idle-id", GUINT_TO_POINTER (0));
return FALSE;
}
static gboolean
handle_set_property (GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *property_name,
GVariant *value,
GError **error,
gpointer user_data)
{
if (g_strcmp0 (property_name, "Title") == 0)
{
if (g_strcmp0 (_global_title, g_variant_get_string (value, NULL)) != 0)
{
GVariantBuilder *builder;
GError *local_error;
g_free (_global_title);
_global_title = g_variant_dup_string (value, NULL);
local_error = NULL;
builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
g_variant_builder_add (builder,
"{sv}",
"Title",
g_variant_new_string (_global_title));
g_dbus_connection_emit_signal (connection,
NULL,
object_path,
"org.freedesktop.DBus.Properties",
"PropertiesChanged",
g_variant_new ("(sa{sv}as)",
interface_name,
builder,
NULL),
&local_error);
g_assert_no_error (local_error);
}
}
else if (g_strcmp0 (property_name, "ReadingAlwaysThrowsError") == 0)
{
/* do nothing - they can't read it after all! */
}
else if (g_strcmp0 (property_name, "WritingAlwaysThrowsError") == 0)
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"Hello AGAIN %s. I thought I said writing this property "
"always results in an error. kthxbye",
sender);
}
return *error == NULL;
}
static void
dialog_handler_emit_response (FileDialogHandle *handle,
const char *interface,
const char *signal,
GVariant *arguments)
{
g_dbus_connection_emit_signal (g_dbus_interface_skeleton_get_connection (handle->base.skeleton),
"org.freedesktop.portal.Desktop",
"/org/freedesktop/portal/desktop",
interface, signal, arguments, NULL);
}
static void documentLoadedCallback(WebKitWebPage*, gpointer userData)
{
bool ok = g_dbus_connection_emit_signal(G_DBUS_CONNECTION(userData),
0,
"/org/webkit/gtk/WebExtensionTest",
"org.webkit.gtk.WebExtensionTest",
"DocumentLoaded",
0,
0);
g_assert(ok);
}
static void emit_property_change(GDBusConnection *connection, const gchar *name, GVariant *value) {
GVariantBuilder builder;
const gchar *invalidated = { NULL };
g_variant_builder_init(&builder, G_VARIANT_TYPE("a{sv}"));
g_variant_builder_add(&builder, "{sv}", name, value);
g_dbus_connection_emit_signal(connection, NULL, TIMEDATED_PATH, PROPERTIES_INTERFACE,
"PropertiesChanged",
g_variant_new("(sa{sv}^as)", TIMEDATED_INTERFACE,
&builder, &invalidated),
NULL);
}
static void emitURIChanged(GDBusConnection* connection, const char* uri)
{
bool ok = g_dbus_connection_emit_signal(
connection,
0,
"/org/webkit/gtk/WebExtensionTest",
"org.webkit.gtk.WebExtensionTest",
"URIChanged",
g_variant_new("(s)", uri),
0);
g_assert(ok);
}
static void emitDocumentLoaded(GDBusConnection* connection)
{
bool ok = g_dbus_connection_emit_signal(
connection,
0,
"/org/webkit/gtk/WebExtensionTest",
"org.webkit.gtk.WebExtensionTest",
"DocumentLoaded",
0,
0);
g_assert(ok);
}
static void uriChangedCallback(WebKitWebPage* webPage, GParamSpec* pspec, gpointer userData)
{
bool ok = g_dbus_connection_emit_signal(
G_DBUS_CONNECTION(userData),
0,
"/org/webkit/gtk/WebExtensionTest",
"org.webkit.gtk.WebExtensionTest",
"URIChanged",
g_variant_new("(s)", webkit_web_page_get_uri(webPage)),
0);
g_assert(ok);
}
/**
* Emit the page created signal that is used in the UI process to finish the
* dbus proxy connection.
*/
static void emit_page_created(GDBusConnection *connection, guint64 pageid)
{
GError *error = NULL;
/* propagate the signal over dbus */
g_dbus_connection_emit_signal(G_DBUS_CONNECTION(connection), NULL,
VB_WEBEXTENSION_OBJECT_PATH, VB_WEBEXTENSION_INTERFACE,
"PageCreated", g_variant_new("(t)", pageid), &error);
if (error) {
g_warning("Failed to emit signal PageCreated: %s", error->message);
g_error_free(error);
}
}
static void
emit_property_changes(XmrMprisPlugin *plugin, GHashTable *changes, const char *interface)
{
GError *error = NULL;
GVariantBuilder *properties;
GVariantBuilder *invalidated;
GVariant *parameters;
gpointer propname, propvalue;
GHashTableIter iter;
/* build property changes */
properties = g_variant_builder_new(G_VARIANT_TYPE ("a{sv}"));
invalidated = g_variant_builder_new(G_VARIANT_TYPE ("as"));
g_hash_table_iter_init(&iter, changes);
while (g_hash_table_iter_next(&iter, &propname, &propvalue))
{
if (propvalue != NULL)
{
g_variant_builder_add(properties,
"{sv}",
propname,
propvalue);
}
else
{
g_variant_builder_add(invalidated, "s", propname);
}
}
parameters = g_variant_new("(sa{sv}as)",
interface,
properties,
invalidated);
g_variant_builder_unref(properties);
g_variant_builder_unref(invalidated);
g_dbus_connection_emit_signal(plugin->connection,
NULL,
MPRIS_OBJECT_NAME,
"org.freedesktop.DBus.Properties",
"PropertiesChanged",
parameters,
&error);
if (error != NULL)
{
g_warning("Unable to send MPRIS property changes for %s: %s",
interface, error->message);
g_clear_error(&error);
}
}
static int command_cb(srs_client_t *c, int idx, int ntoken, char **tokens,
uint32_t *start, uint32_t *end, srs_audiobuf_t *audio)
{
static const char *events[] = {
[CMD_PLAY] = "play",
[CMD_STOP] = "stop",
[CMD_PAUSE] = "pause",
[CMD_NEXT] = "next",
[CMD_PREV] = "previous",
};
static int nevent = MRP_ARRAY_SIZE(events);
wrtc_t *wrtc = (wrtc_t *)c->user_data;
const char *event;
GVariantBuilder *vb;
GVariant *args;
MRP_UNUSED(start);
MRP_UNUSED(end);
MRP_UNUSED(audio);
MRP_UNUSED(tokens);
MRP_UNUSED(ntoken);
if (!wrtc->name) {
mrp_log_error("WRT media client: can't relay, got no D-Bus name.");
return TRUE;
}
if (idx < 0 || idx >= nevent) {
mrp_log_error("WRT media client: got invalid command #%d.", idx);
return TRUE;
}
else
event = events[idx];
mrp_log_info("WRT media client: relaying command %s.", event);
vb = g_variant_builder_new(G_VARIANT_TYPE("as"));
g_variant_builder_add(vb, "s", event);
args = g_variant_new("(as)", vb);
g_variant_builder_unref(vb);
g_dbus_connection_emit_signal(wrtc->gdbus, NULL,
"/srs", "org.tizen.srs", "Result",
args, NULL);
return TRUE;
}
void actionInvoked(notification * n, const char *identifier)
{
GVariant *body = g_variant_new("(us)", n->id, identifier);
GError *err = NULL;
g_dbus_connection_emit_signal(dbus_conn,
n->dbus_client,
"/org/freedesktop/Notifications",
"org.freedesktop.Notifications",
"ActionInvoked", body, &err);
if (err) {
printf("ActionInvoked ERROR\n");
}
}
void AbstractDBusInterface::updateValue(AbstractProperty *property)
{
if(mConnection == nullptr)
{
return;
}
GError *error = NULL;
g_dbus_connection_emit_signal(mConnection, NULL, mObjectPath.c_str(), mInterfaceName.c_str(), property->name().c_str(), g_variant_new("(v)",property->toGVariant()), &error);
if(error)
{
throw -1;
}
}
static gboolean
on_app_schedule_changed_cb (gpointer user_data)
{
App *app = user_data;
print_debug ("Emitting changed");
g_dbus_connection_emit_signal (app->connection,
NULL, /* destination_bus_name */
"/org/gnome/Shell/CalendarServer",
"org.gnome.Shell.CalendarServer",
"Changed",
NULL, /* no params */
NULL);
app->changed_timeout_id = 0;
return FALSE;
}
static gboolean prv_connector_notify(dleyna_connector_id_t connection,
const gchar *object_path,
const gchar *interface_name,
const gchar *notification_name,
GVariant *parameters,
GError **error)
{
return g_dbus_connection_emit_signal((GDBusConnection *)connection,
NULL,
object_path,
interface_name,
notification_name,
parameters,
NULL);
}
