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); }