static void modem_manager_appeared (NMModemManager *self, gboolean enumerate_devices) { NMModemManagerPrivate *priv = NM_MODEM_MANAGER_GET_PRIVATE (self); if (priv->poke_id) { g_source_remove (priv->poke_id); priv->poke_id = 0; } nm_log_info (LOGD_MB, "modem-manager is now available"); priv->proxy = dbus_g_proxy_new_for_name (nm_dbus_manager_get_connection (priv->dbus_mgr), MM_DBUS_SERVICE, MM_DBUS_PATH, MM_DBUS_INTERFACE); dbus_g_proxy_add_signal (priv->proxy, "DeviceAdded", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->proxy, "DeviceAdded", G_CALLBACK (modem_added), self, NULL); dbus_g_proxy_add_signal (priv->proxy, "DeviceRemoved", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->proxy, "DeviceRemoved", G_CALLBACK (modem_removed), self, NULL); if (enumerate_devices) dbus_g_proxy_begin_call (priv->proxy, "EnumerateDevices", enumerate_devices_done, self, NULL, G_TYPE_INVALID); }
static void bluez_connect (NMBluezManager *self) { NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE (self); DBusGConnection *connection; g_return_if_fail (priv->proxy == NULL); connection = nm_dbus_manager_get_connection (priv->dbus_mgr); if (!connection) return; priv->proxy = dbus_g_proxy_new_for_name (connection, BLUEZ_SERVICE, BLUEZ_MANAGER_PATH, BLUEZ_MANAGER_INTERFACE); dbus_g_proxy_add_signal (priv->proxy, "AdapterRemoved", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->proxy, "AdapterRemoved", G_CALLBACK (adapter_removed), self, NULL); dbus_g_proxy_add_signal (priv->proxy, "DefaultAdapterChanged", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->proxy, "DefaultAdapterChanged", G_CALLBACK (default_adapter_changed), self, NULL); query_default_adapter (self); }
static void g_udisks_volume_monitor_init(GUDisksVolumeMonitor *self) { self->con = dbus_g_bus_get(DBUS_BUS_SYSTEM, NULL); if(self->con) { GPtrArray* ret; /* FIXME: handle disconnecting from dbus */ self->udisks_proxy = dbus_g_proxy_new_for_name(self->con, "org.freedesktop.UDisks", "/org/freedesktop/UDisks", "org.freedesktop.UDisks"); if(org_freedesktop_UDisks_enumerate_devices(self->udisks_proxy, &ret, NULL)) { int i; char** paths = (char**)ret->pdata; for(i=0; i<ret->len;++i) add_device(self, self->udisks_proxy, paths[i], FALSE); g_ptr_array_free(ret, TRUE); } dbus_g_proxy_add_signal(self->udisks_proxy, "DeviceAdded", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_add_signal(self->udisks_proxy, "DeviceRemoved", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_add_signal(self->udisks_proxy, "DeviceChanged", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal(self->udisks_proxy, "DeviceAdded", G_CALLBACK(on_device_added), self, NULL); dbus_g_proxy_connect_signal(self->udisks_proxy, "DeviceRemoved", G_CALLBACK(on_device_removed), self, NULL); dbus_g_proxy_connect_signal(self->udisks_proxy, "DeviceChanged", G_CALLBACK(on_device_changed), self, NULL); /* find drives for volumes */ if(self->volumes && self->drives) g_list_foreach(self->volumes, (GFunc)update_volume_drive, self); } }
static void listen_tracker (GtkListStore *model) { #if 0 DBusGConnection *bus; DBusGProxy *wrap; bus = dbus_g_bus_get (DBUS_BUS_SESSION, NULL); dbus_g_object_register_marshaller (marshal_VOID__BOXED_BOXED, G_TYPE_NONE, G_TYPE_STRV, G_TYPE_STRV, G_TYPE_INVALID); wrap = dbus_g_proxy_new_for_name (bus, "org.freedesktop.Tracker1", "/org/freedesktop/Tracker1/Resources/Classes/mfo/FeedChannel", "org.freedesktop.Tracker1.Resources.Class"); dbus_g_proxy_add_signal (wrap, "SubjectsAdded", G_TYPE_STRV, G_TYPE_INVALID); dbus_g_proxy_connect_signal (wrap, "SubjectsAdded", G_CALLBACK (channel_added_cb), model, NULL); dbus_g_proxy_add_signal (wrap, "SubjectsChanged", G_TYPE_STRV, G_TYPE_STRV, G_TYPE_INVALID); dbus_g_proxy_connect_signal (wrap, "SubjectsChanged", G_CALLBACK (channel_changed_cb), model, NULL); dbus_g_proxy_add_signal (wrap, "SubjectsRemoved", G_TYPE_STRV, G_TYPE_INVALID); dbus_g_proxy_connect_signal (wrap, "SubjectsRemoved", G_CALLBACK (channel_removed_cb), model, NULL); #endif }
static void device_add_cb(RoccatConfigWindow *roccat_window, gpointer user_data) { IskuconfigWindow *window = ISKUCONFIG_WINDOW(roccat_window); IskuconfigWindowPrivate *priv = window->priv; GError *local_error = NULL; guint i; IskuRkp *rkp; RoccatDevice *device; IskuconfigProfilePage *profile_page; guint actual_profile_index; device = roccat_config_window_get_device(roccat_window); for (i = 0; i < ISKU_PROFILE_NUM; ++i) { profile_page = ISKUCONFIG_PROFILE_PAGE(roccat_config_window_get_page(roccat_window, i)); rkp = iskuconfig_profile_page_get_rkp(profile_page); isku_rkp_update_from_device(device, rkp, i); iskuconfig_profile_page_set_rkp(profile_page, rkp); isku_rkp_free(rkp); } actual_profile_index = isku_actual_profile_read(device, &local_error); if (!roccat_handle_error_dialog(GTK_WINDOW(window), _("Could not read actual profile"), &local_error)) return; roccat_config_window_set_active_page(roccat_window, actual_profile_index); dbus_g_proxy_connect_signal(priv->dbus_proxy, "ProfileChanged", G_CALLBACK(actual_profile_changed_from_device_cb), window, NULL); dbus_g_proxy_connect_signal(priv->dbus_proxy, "BrightnessChanged", G_CALLBACK(brightness_changed_from_device_cb), window, NULL); dbus_g_proxy_connect_signal(priv->dbus_proxy, "MacroChanged", G_CALLBACK(macro_changed_from_device_cb), window, NULL); }
/* Initialise le backend de QL. */ static void cd_quodlibet_start (void) { // register to the signals dbus_g_proxy_add_signal(myData.dbus_proxy_player, "paused", G_TYPE_INVALID); dbus_g_proxy_connect_signal(myData.dbus_proxy_player, "paused", G_CALLBACK(on_pause), NULL, NULL); dbus_g_proxy_add_signal(myData.dbus_proxy_player, "unpaused", G_TYPE_NONE, G_TYPE_INVALID); // idem. dbus_g_proxy_connect_signal(myData.dbus_proxy_player, "unpaused", G_CALLBACK(on_unpaused), NULL, NULL); dbus_g_proxy_add_signal(myData.dbus_proxy_player, "song-started", QL_DBUS_TYPE_SONG_METADATA, G_TYPE_INVALID); dbus_g_proxy_connect_signal(myData.dbus_proxy_player, "song-started", G_CALLBACK(onChangeSong), NULL, NULL); // get the current state. _quodlibet_getPlaying (); cd_quodlibet_getSongInfos (); cd_musicplayer_update_icon (); }
/** * gpk_session_init: * @session: This class instance **/ static void gpk_session_init (GpkSession *session) { DBusGConnection *connection; GError *error = NULL; session->priv = GPK_SESSION_GET_PRIVATE (session); session->priv->is_idle_old = FALSE; session->priv->is_inhibited_old = FALSE; session->priv->proxy_client_private = NULL; connection = dbus_g_bus_get (DBUS_BUS_SESSION, NULL); /* get org.gnome.Session interface */ session->priv->proxy = dbus_g_proxy_new_for_name_owner (connection, GPK_SESSION_MANAGER_SERVICE, GPK_SESSION_MANAGER_PATH, GPK_SESSION_MANAGER_INTERFACE, &error); if (session->priv->proxy == NULL) { g_warning ("DBUS error: %s", error->message); g_error_free (error); return; } /* get org.gnome.Session.Presence interface */ session->priv->proxy_presence = dbus_g_proxy_new_for_name_owner (connection, GPK_SESSION_MANAGER_SERVICE, GPK_SESSION_MANAGER_PRESENCE_PATH, GPK_SESSION_MANAGER_PRESENCE_INTERFACE, &error); if (session->priv->proxy_presence == NULL) { g_warning ("DBUS error: %s", error->message); g_error_free (error); return; } /* get properties interface */ session->priv->proxy_prop = dbus_g_proxy_new_for_name_owner (connection, GPK_SESSION_MANAGER_SERVICE, GPK_SESSION_MANAGER_PRESENCE_PATH, GPK_DBUS_PROPERTIES_INTERFACE, &error); if (session->priv->proxy_prop == NULL) { g_warning ("DBUS error: %s", error->message); g_error_free (error); return; } /* get StatusChanged */ dbus_g_proxy_add_signal (session->priv->proxy_presence, "StatusChanged", G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (session->priv->proxy_presence, "StatusChanged", G_CALLBACK (gpk_session_presence_status_changed_cb), session, NULL); /* get InhibitorAdded */ dbus_g_proxy_add_signal (session->priv->proxy, "InhibitorAdded", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal (session->priv->proxy, "InhibitorAdded", G_CALLBACK (gpk_session_inhibit_changed_cb), session, NULL); /* get InhibitorRemoved */ dbus_g_proxy_add_signal (session->priv->proxy, "InhibitorRemoved", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal (session->priv->proxy, "InhibitorRemoved", G_CALLBACK (gpk_session_inhibit_changed_cb), session, NULL); /* coldplug */ session->priv->is_inhibited_old = gpk_session_is_inhibited (session); session->priv->is_idle_old = gpk_session_is_idle (session); g_debug ("idle: %i, inhibited: %i", session->priv->is_idle_old, session->priv->is_inhibited_old); }
static void start_avahi_service_browser(DBusGConnection *bus_system){ GError *error = NULL; char *service_browser_path; if (!dbus_g_proxy_call(proxy_avahi_service, "ServiceBrowserNew", &error, G_TYPE_INT, -1, G_TYPE_INT, -1, G_TYPE_STRING, "_http._tcp", G_TYPE_STRING, "local", G_TYPE_UINT, 0, G_TYPE_INVALID, DBUS_TYPE_G_OBJECT_PATH, &service_browser_path, G_TYPE_INVALID)) lose_gerror("Failed to call ServiceBrowserNew", error); printf("new service browser (%s) has started.\n", service_browser_path); proxy_avahi_service_browser = dbus_g_proxy_new_for_name(bus_system, "org.freedesktop.Avahi", service_browser_path, "org.freedesktop.Avahi.ServiceBrowser"); dbus_g_object_register_marshaller( _avahi_marshal_VOID__INT_INT_STRING_STRING_STRING_UINT, G_TYPE_NONE, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_INVALID); // dbus_g_object_register_marshaller( // _avahi_marshal_VOID__INT_INT_STRING_STRING_STRING_INT_UINT, // G_TYPE_NONE, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, // G_TYPE_STRING, G_TYPE_INT, G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_add_signal(proxy_avahi_service_browser, "ItemNew", G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_connect_signal(proxy_avahi_service_browser, "ItemNew", G_CALLBACK(service_browser_ItemNew), NULL, NULL); dbus_g_proxy_add_signal(proxy_avahi_service_browser, "ItemRemove", G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_connect_signal(proxy_avahi_service_browser, "ItemRemove", G_CALLBACK(service_browser_ItemRemove), NULL, NULL); }
static void init_network_manager (GUPnPNetworkManager *manager) { GUPnPNetworkManagerPrivate *priv; DBusError derror; GMainContext *main_context; priv = manager->priv; g_object_get (manager, "main-context", &main_context, NULL); /* Do fake open to initialize types */ dbus_g_connection_open ("", NULL); dbus_error_init (&derror); priv->dbus_connection = dbus_bus_get_private (DBUS_BUS_SYSTEM, &derror); if (priv->dbus_connection == NULL) { g_message ("Failed to connect to System Bus: %s", derror.message); return; } dbus_connection_setup_with_g_main (priv->dbus_connection, main_context); priv->connection = dbus_connection_get_g_connection (priv->dbus_connection); priv->manager_proxy = dbus_g_proxy_new_for_name (priv->connection, DBUS_SERVICE_NM, MANAGER_PATH, MANAGER_INTERFACE); dbus_g_proxy_add_signal (priv->manager_proxy, "DeviceAdded", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->manager_proxy, "DeviceAdded", G_CALLBACK (on_device_added), manager, NULL); dbus_g_proxy_add_signal (priv->manager_proxy, "DeviceRemoved", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->manager_proxy, "DeviceRemoved", G_CALLBACK (on_device_removed), manager, NULL); dbus_g_proxy_begin_call (priv->manager_proxy, "GetDevices", get_devices_cb, manager, NULL, G_TYPE_INVALID); }
gboolean _mojito_client_service_setup (MojitoClientService *service, const gchar *service_name, GError **error_out) { MojitoClientServicePrivate *priv = GET_PRIVATE (service); GError *error = NULL; if (!_mojito_client_service_setup_proxy_for_iface (service, service_name, SERVICE_IFACE, &error)) { g_propagate_error (error_out, error); return FALSE; } dbus_g_proxy_add_signal (priv->proxies[SERVICE_IFACE], "AvatarRetrieved", G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->proxies[SERVICE_IFACE], "AvatarRetrieved", (GCallback)_avatar_retrieved_cb, service, NULL); dbus_g_proxy_add_signal (priv->proxies[SERVICE_IFACE], "CapabilitiesChanged", G_TYPE_STRV, NULL); dbus_g_proxy_connect_signal (priv->proxies[SERVICE_IFACE], "CapabilitiesChanged", (GCallback)_capabilities_changed_cb, service, NULL); dbus_g_proxy_add_signal (priv->proxies[SERVICE_IFACE], "StatusUpdated", G_TYPE_BOOLEAN, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->proxies[SERVICE_IFACE], "StatusUpdated", (GCallback)_status_updated_cb, service, NULL); dbus_g_proxy_add_signal (priv->proxies[SERVICE_IFACE], "UserChanged", G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->proxies[SERVICE_IFACE], "UserChanged", (GCallback)_user_changed_cb, service, NULL); return TRUE; }
static GObject* cryptui_keyset_constructor (GType type, guint n_props, GObjectConstructParam* props) { DBusGConnection *bus; CryptUIKeyset *keyset; GError *error = NULL; GObject *obj; gchar *path; obj = G_OBJECT_CLASS (cryptui_keyset_parent_class)->constructor (type, n_props, props); keyset = CRYPTUI_KEYSET (obj); if (!keyset->priv->keytype) { g_warning ("no keytype was set on the keyset"); goto finally; } bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error); if (!bus) { g_critical ("couldn't get the session bus: %s", error->message); g_clear_error (&error); goto finally; } path = g_strdup_printf("/org/gnome/seahorse/keys/%s", keyset->priv->keytype); keyset->priv->remote_keyset = dbus_g_proxy_new_for_name (bus, "org.gnome.seahorse", path, "org.gnome.seahorse.Keys"); keyset->priv->remote_service = dbus_g_proxy_new_for_name (bus, "org.gnome.seahorse", "/org/gnome/seahorse/keys", "org.gnome.seahorse.KeyService"); g_free (path); if (!keyset->priv->remote_keyset || !keyset->priv->remote_service) { g_critical ("couldn't connect to the dbus service"); goto finally; } cryptui_keyset_refresh (keyset); dbus_g_proxy_add_signal (keyset->priv->remote_keyset, "KeyAdded", G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_add_signal (keyset->priv->remote_keyset, "KeyRemoved", G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_add_signal (keyset->priv->remote_keyset, "KeyChanged", G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_connect_signal (keyset->priv->remote_keyset, "KeyAdded", G_CALLBACK (key_added), keyset, NULL); dbus_g_proxy_connect_signal (keyset->priv->remote_keyset, "KeyRemoved", G_CALLBACK (key_removed), keyset, NULL); dbus_g_proxy_connect_signal (keyset->priv->remote_keyset, "KeyChanged", G_CALLBACK (key_changed), keyset, NULL); finally: return obj; }
/** * gpm_phone_service_appeared_cb: */ static void gpm_phone_service_appeared_cb (GDBusConnection *connection, const gchar *name, const gchar *name_owner, GpmPhone *phone) { GError *error = NULL; g_return_if_fail (GPM_IS_PHONE (phone)); if (phone->priv->connection == NULL) { egg_debug ("get connection"); g_clear_error (&error); phone->priv->connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error); if (error != NULL) { egg_warning ("Could not connect to DBUS daemon: %s", error->message); g_error_free (error); phone->priv->connection = NULL; return; } } if (phone->priv->proxy == NULL) { egg_debug ("get proxy"); g_clear_error (&error); phone->priv->proxy = dbus_g_proxy_new_for_name_owner (phone->priv->connection, MATE_PHONE_MANAGER_DBUS_SERVICE, MATE_PHONE_MANAGER_DBUS_PATH, MATE_PHONE_MANAGER_DBUS_INTERFACE, &error); if (error != NULL) { egg_warning ("Cannot connect, maybe the daemon is not running: %s", error->message); g_error_free (error); phone->priv->proxy = NULL; return; } /* complicated type. ick */ dbus_g_object_register_marshaller(gpm_marshal_VOID__UINT_UINT_BOOLEAN, G_TYPE_NONE, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_BOOLEAN, G_TYPE_INVALID); /* get BatteryStateChanged */ dbus_g_proxy_add_signal (phone->priv->proxy, "BatteryStateChanged", G_TYPE_UINT, G_TYPE_UINT, G_TYPE_BOOLEAN, G_TYPE_INVALID); dbus_g_proxy_connect_signal (phone->priv->proxy, "BatteryStateChanged", G_CALLBACK (gpm_phone_battery_state_changed), phone, NULL); /* get NumberBatteriesChanged */ dbus_g_proxy_add_signal (phone->priv->proxy, "NumberBatteriesChanged", G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (phone->priv->proxy, "NumberBatteriesChanged", G_CALLBACK (gpm_phone_num_batteries_changed), phone, NULL); } }
/** * gpm_session_register_client: **/ gboolean gpm_session_register_client (GpmSession *session, const gchar *app_id, const gchar *client_startup_id) { gboolean ret = FALSE; gchar *client_id = NULL; GError *error = NULL; DBusGConnection *connection; g_return_val_if_fail (GPM_IS_SESSION (session), FALSE); /* no mate-session */ if (session->priv->proxy == NULL) { egg_warning ("no mate-session"); goto out; } /* find out if this change altered the inhibited state */ ret = dbus_g_proxy_call (session->priv->proxy, "RegisterClient", &error, G_TYPE_STRING, app_id, G_TYPE_STRING, client_startup_id, G_TYPE_INVALID, DBUS_TYPE_G_OBJECT_PATH, &client_id, G_TYPE_INVALID); if (!ret) { egg_warning ("failed to register client '%s': %s", client_startup_id, error->message); g_error_free (error); goto out; } /* get org.mate.Session.ClientPrivate interface */ connection = dbus_g_bus_get (DBUS_BUS_SESSION, NULL); session->priv->proxy_client_private = dbus_g_proxy_new_for_name_owner (connection, GPM_SESSION_MANAGER_SERVICE, client_id, GPM_SESSION_MANAGER_CLIENT_PRIVATE_INTERFACE, &error); if (session->priv->proxy_client_private == NULL) { egg_warning ("DBUS error: %s", error->message); g_error_free (error); goto out; } /* get Stop */ dbus_g_proxy_add_signal (session->priv->proxy_client_private, "Stop", G_TYPE_INVALID); dbus_g_proxy_connect_signal (session->priv->proxy_client_private, "Stop", G_CALLBACK (gpm_session_stop_cb), session, NULL); /* get QueryEndSession */ dbus_g_proxy_add_signal (session->priv->proxy_client_private, "QueryEndSession", G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (session->priv->proxy_client_private, "QueryEndSession", G_CALLBACK (gpm_session_query_end_session_cb), session, NULL); /* get EndSession */ dbus_g_proxy_add_signal (session->priv->proxy_client_private, "EndSession", G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (session->priv->proxy_client_private, "EndSession", G_CALLBACK (gpm_session_end_session_cb), session, NULL); egg_debug ("registered startup '%s' to client id '%s'", client_startup_id, client_id); out: g_free (client_id); return ret; }
gboolean get_quodlibet_info(struct TrackInfo* ti) { DBusGConnection *connection; DBusGProxy *player, *shell; GError *error = 0; char buf[100], status[100]; static gboolean connected = FALSE; connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error); if (connection == NULL) { trace("Failed to open connection to dbus: %s\n", error->message); g_error_free (error); return FALSE; } if (!dbus_g_running(connection, "net.sacredchao.QuodLibet")) { ti->status = STATUS_OFF; return TRUE; } player = dbus_g_proxy_new_for_name(connection, "net.sacredchao.QuodLibet", "/net/sacredchao/QuodLibet", "net.sacredchao.QuodLibet"); if (!connected) { dbus_g_proxy_add_signal(player, "Paused", G_TYPE_INVALID); dbus_g_proxy_connect_signal(player, "Paused", G_CALLBACK(cb_quodlibet_paused), (gpointer) STATUS_PAUSED, 0); dbus_g_proxy_add_signal(player, "Unpaused", G_TYPE_INVALID); dbus_g_proxy_connect_signal(player, "Unpaused", G_CALLBACK(cb_quodlibet_paused), (gpointer) STATUS_NORMAL, 0); connected = TRUE; } GHashTable *table; if (!dbus_g_proxy_call(player, "CurrentSong", &error, G_TYPE_INVALID, dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_STRING), &table, G_TYPE_INVALID)) { ti->status = STATUS_OFF; return TRUE; } ti->status = g_state; quodlibet_hash_str(table, "artist", ti->artist); quodlibet_hash_str(table, "album", ti->album); quodlibet_hash_str(table, "title", ti->track); quodlibet_hash_str(table, "~#length", buf); sscanf(buf, "%d", &ti->totalSecs); g_hash_table_destroy(table); return TRUE; }
static void interface_add_done (NMSupplicantInterface *self, char *path) { NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self); nm_log_dbg (LOGD_SUPPLICANT, "(%s): interface added to supplicant", priv->dev); priv->object_path = path; priv->iface_proxy = dbus_g_proxy_new_for_name (nm_dbus_manager_get_connection (priv->dbus_mgr), WPAS_DBUS_SERVICE, path, WPAS_DBUS_IFACE_INTERFACE); dbus_g_object_register_marshaller (g_cclosure_marshal_VOID__BOXED, G_TYPE_NONE, DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_add_signal (priv->iface_proxy, "PropertiesChanged", DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->iface_proxy, "PropertiesChanged", G_CALLBACK (wpas_iface_properties_changed), self, NULL); dbus_g_proxy_add_signal (priv->iface_proxy, "ScanDone", G_TYPE_BOOLEAN, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->iface_proxy, "ScanDone", G_CALLBACK (wpas_iface_scan_done), self, NULL); dbus_g_object_register_marshaller (_nm_marshal_VOID__STRING_BOXED, G_TYPE_NONE, DBUS_TYPE_G_OBJECT_PATH, DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_add_signal (priv->iface_proxy, "BSSAdded", DBUS_TYPE_G_OBJECT_PATH, DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->iface_proxy, "BSSAdded", G_CALLBACK (wpas_iface_bss_added), self, NULL); priv->props_proxy = dbus_g_proxy_new_for_name (nm_dbus_manager_get_connection (priv->dbus_mgr), WPAS_DBUS_SERVICE, path, DBUS_INTERFACE_PROPERTIES); /* Get initial properties */ wpas_iface_get_props (self); set_state (self, NM_SUPPLICANT_INTERFACE_STATE_READY); }
int main() { DBusGConnection *bus; GMainLoop *mainLoop = NULL; DBusGProxy* proxy; GError *error = NULL; int fd; int err; const char* fifopath = "C:\\mkfifo8.file"; const char* buf1 = "done"; g_type_init(); bus = dbus_g_bus_get(DBUS_BUS_SESSION,NULL); proxy = dbus_g_proxy_new_for_name (bus, "org.designfu.TestService", "/org/designfu/TestService/object", "org.designfu.TestService"); /* Tell DBus what the type signature of the signal callback is; this * allows us to sanity-check incoming messages before invoking the * callback. You need to do this once for each proxy you create, * not every time you want to connect to the signal. */ dbus_g_proxy_add_signal (proxy, "HelloSignal", G_TYPE_STRING, G_TYPE_INVALID); /* Actually connect to the signal. Note you can call * dbus_g_proxy_connect_signal multiple times for one invocation of * dbus_g_proxy_add_signal. */ dbus_g_proxy_connect_signal (proxy, "HelloSignal", G_CALLBACK (hello_signal_handler), NULL, NULL); dbus_g_proxy_connect_signal (proxy, "HelloSignal", G_CALLBACK (hello_signal_handler1), NULL, NULL); fd = open(fifopath, O_WRONLY); sleep(2); if (fd > 0) { err = write(fd, buf1, strlen(buf1)); close(fd); } mainLoop = g_main_loop_new(NULL,FALSE); g_main_loop_run(mainLoop); return 0; }
static void init_network_manager (GUPnPNetworkManager *manager) { GUPnPNetworkManagerPrivate *priv; GError *error; error = NULL; priv = manager->priv; priv->connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error); if (priv->connection == NULL) { g_warning ("Failed to connect to System Bus: %s", error->message); return; } priv->manager_proxy = dbus_g_proxy_new_for_name (priv->connection, DBUS_SERVICE_NM, MANAGER_PATH, MANAGER_INTERFACE); dbus_g_proxy_add_signal (priv->manager_proxy, "DeviceAdded", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->manager_proxy, "DeviceAdded", G_CALLBACK (on_device_added), manager, NULL); dbus_g_proxy_add_signal (priv->manager_proxy, "DeviceRemoved", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->manager_proxy, "DeviceRemoved", G_CALLBACK (on_device_removed), manager, NULL); dbus_g_proxy_begin_call (priv->manager_proxy, "GetDevices", get_devices_cb, manager, NULL, G_TYPE_INVALID); }
static transfer_info_t *__bt_create_transfer(DBusGConnection *conn, const char *transfer_path) { transfer_info_t *transfer_info = g_new0(transfer_info_t, 1); transfer_info->transfer_proxy = dbus_g_proxy_new_for_name(conn, "org.openobex", transfer_path, "org.openobex.Transfer"); if (NULL == transfer_info->transfer_proxy) { DBG("proxy faliled"); g_free(transfer_info); return NULL; } dbus_g_proxy_add_signal(transfer_info->transfer_proxy, "Progress", G_TYPE_INT, G_TYPE_INT, G_TYPE_INVALID); dbus_g_proxy_connect_signal(transfer_info->transfer_proxy, "Progress", G_CALLBACK(__bt_transfer_progress_cb), transfer_info, NULL); transfer_info->transfer_id = __bt_get_transfer_id(transfer_path); DBG("Transfer ID : %d \n", transfer_info->transfer_id); return transfer_info; }
static gboolean online_init (void) { DBusGConnection *conn; if (proxy) return TRUE; conn = dbus_g_bus_get (DBUS_BUS_SYSTEM, NULL); if (!conn) { g_warning ("Cannot get connection to system message bus"); return FALSE; } proxy = dbus_g_proxy_new_for_name (conn, "net.connman", "/", "net.connman.Manager"); dbus_g_object_register_marshaller (g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_add_signal (proxy, "StateChanged", G_TYPE_STRING, NULL); dbus_g_proxy_connect_signal (proxy, "StateChanged", (GCallback)state_changed, NULL, NULL); current_state = FALSE; /* Get the current state */ dbus_g_proxy_begin_call (proxy, "GetState", got_state_cb, NULL, NULL, G_TYPE_INVALID); return TRUE; }
static void geoclue_gsmloc_ofono_init (GeoclueGsmlocOfono *ofono) { GeoclueGsmlocOfonoPrivate *priv = GET_PRIVATE (ofono); DBusGConnection *system_bus; priv->modems = NULL; priv->available = FALSE; system_bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, NULL); if (!system_bus) { g_warning ("failed to connect to DBus system bus"); return; } priv->ofono_manager = dbus_g_proxy_new_for_name (system_bus, "org.ofono", "/", "org.ofono.Manager"); org_ofono_Manager_get_properties_async (priv->ofono_manager, (org_ofono_Manager_get_properties_reply)manager_get_properties_cb, ofono); dbus_g_proxy_add_signal (priv->ofono_manager,"PropertyChanged", G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->ofono_manager, "PropertyChanged", G_CALLBACK (manager_property_changed_cb), ofono, NULL); }
static void set_session_over_handler (DBusGConnection *bus, MateSettingsManager *manager) { DBusGProxy *session_proxy; g_assert (bus != NULL); mate_settings_profile_start (NULL); session_proxy = dbus_g_proxy_new_for_name (bus, MATE_SESSION_DBUS_NAME, MATE_SESSION_DBUS_OBJECT, MATE_SESSION_DBUS_INTERFACE); dbus_g_object_register_marshaller ( g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, G_TYPE_INVALID); dbus_g_proxy_add_signal (session_proxy, "SessionOver", G_TYPE_INVALID); dbus_g_proxy_connect_signal (session_proxy, "SessionOver", G_CALLBACK (on_session_over), manager, NULL); watch_for_term_signal (manager); mate_settings_profile_end (NULL); }
/** * Connects to adapter added and removed signals, * and possibly others in the future */ static void connect_manager_signals() { dbus_g_proxy_add_signal(manager, "AdapterAdded", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_add_signal(manager, "AdapterRemoved", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID); dbus_g_proxy_connect_signal(manager, "AdapterAdded", G_CALLBACK(adapter_added), NULL, NULL); dbus_g_proxy_connect_signal(manager, "AdapterRemoved", G_CALLBACK(adapter_removed), NULL, NULL); }
int main (int argc, char *argv[]) { DBusGConnection *bus; DBusGProxy *bus_proxy; GMainLoop *loop = NULL; GError *err = NULL; gboolean nm_running; /* Initialize GType system */ g_type_init (); g_print ("Monitor 'org.freedesktop.NetworkManager' D-Bus name\n"); g_print ("===================================================\n"); /* Get system bus */ bus = dbus_g_bus_get (DBUS_BUS_SYSTEM, NULL); /* Create a D-Bus proxy to D-Bus daemon */ bus_proxy = dbus_g_proxy_new_for_name (bus, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus"); if (!bus_proxy) { g_message ("Error: Couldn't create D-Bus object proxy for org.freedesktop.DBus."); dbus_g_connection_unref (bus); return -1; } /* Call NameHasOwner method to find out if NM is running. When NM runs it claims * 'org.freedesktop.NetworkManager' service name on D-Bus */ if (!org_freedesktop_DBus_name_has_owner (bus_proxy, NM_DBUS_SERVICE, &nm_running, &err)) { g_message ("Error: NameHasOwner request failed: %s", (err && err->message) ? err->message : "(unknown)"); g_clear_error (&err); g_object_unref (bus_proxy); dbus_g_connection_unref (bus); return -1; } g_print ("NM is %s\n", nm_running ? "running" : "not running"); /* Connect to NameOwnerChanged signal to monitor NM running state */ dbus_g_proxy_add_signal (bus_proxy, "NameOwnerChanged", G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_connect_signal (bus_proxy, "NameOwnerChanged", G_CALLBACK (proxy_name_owner_changed), &nm_running, NULL); loop = g_main_loop_new (NULL, FALSE); /* Create main loop */ g_main_loop_run (loop); /* Run main loop */ g_object_unref (bus_proxy); dbus_g_connection_unref (bus); return 0; }
static void device_add_cb(RoccatConfigWindow *roccat_window, gpointer user_data) { KonepureconfigWindow *window = KONEPURECONFIG_WINDOW(roccat_window); KonepureconfigWindowPrivate *priv = window->priv; GError *local_error = NULL; guint i; KoneplusRmp *rmp; RoccatDevice *device; KonepureconfigProfilePage *profile_page; guint actual_profile_index; device = roccat_config_window_get_device(roccat_window); for (i = 0; i < KONEPLUS_PROFILE_NUM; ++i) { profile_page = KONEPURECONFIG_PROFILE_PAGE(roccat_config_window_get_page(roccat_window, i)); rmp = konepureconfig_profile_page_get_rmp(profile_page); konepure_rmp_update_from_device(rmp, device, i); konepureconfig_profile_page_set_rmp(profile_page, rmp); koneplus_rmp_free(rmp); } actual_profile_index = koneplus_actual_profile_read(device, &local_error); if (!roccat_handle_error_dialog(GTK_WINDOW(window), _("Could not read actual profile"), &local_error)) return; roccat_config_window_set_active_page(roccat_window, actual_profile_index); dbus_g_proxy_connect_signal(priv->dbus_proxy, "ProfileChanged", G_CALLBACK(actual_profile_changed_from_device_cb), window, NULL); }
void cd_NetworkMonitor_get_new_access_point (void) { myData.iQuality = WIFI_QUALITY_NO_SIGNAL; if (myData.cAccessPoint != NULL) { cd_debug (" on recupere le nouveau point d'acces...\n"); if (myData.dbus_proxy_ActiveAccessPoint) { dbus_g_proxy_disconnect_signal(myData.dbus_proxy_ActiveAccessPoint, "PropertiesChanged", G_CALLBACK(onChangeAccessPointProperties), NULL); g_object_unref (myData.dbus_proxy_ActiveAccessPoint); } if (myData.dbus_proxy_ActiveAccessPoint_prop) { g_object_unref (myData.dbus_proxy_ActiveAccessPoint_prop); } myData.dbus_proxy_ActiveAccessPoint_prop = cairo_dock_create_new_system_proxy ( "org.freedesktop.NetworkManager", myData.cAccessPoint, "org.freedesktop.DBus.Properties"); myData.dbus_proxy_ActiveAccessPoint = cairo_dock_create_new_system_proxy ( "org.freedesktop.NetworkManager", myData.cAccessPoint, "org.freedesktop.NetworkManager.AccessPoint"); dbus_g_proxy_add_signal(myData.dbus_proxy_ActiveAccessPoint, "PropertiesChanged", CD_DBUS_TYPE_HASH_TABLE, G_TYPE_INVALID); dbus_g_proxy_connect_signal(myData.dbus_proxy_ActiveAccessPoint, "PropertiesChanged", G_CALLBACK(onChangeAccessPointProperties), NULL, NULL); cd_NetworkMonitor_get_access_point_properties (); } }
static void add_device_from_path (char *device_path, GUPnPNetworkManager *manager) { NMDevice *nm_device; nm_device = nm_device_new (manager, device_path); manager->priv->nm_devices = g_list_append (manager->priv->nm_devices, nm_device); dbus_g_proxy_add_signal (nm_device->device_proxy, "StateChanged", G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (nm_device->device_proxy, "StateChanged", G_CALLBACK (on_device_state_changed), nm_device, NULL); dbus_g_proxy_begin_call (nm_device->prop_proxy, "Get", get_device_state_cb, nm_device, NULL, G_TYPE_STRING, DEVICE_INTERFACE, G_TYPE_STRING, "State", G_TYPE_INVALID); }
static gboolean register_manager (GsmManager *manager) { GError *error = NULL; error = NULL; manager->priv->connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error); if (manager->priv->connection == NULL) { if (error != NULL) { g_critical ("error getting session bus: %s", error->message); g_error_free (error); } return FALSE; } manager->priv->bus_proxy = dbus_g_proxy_new_for_name (manager->priv->connection, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS); dbus_g_proxy_add_signal (manager->priv->bus_proxy, "NameOwnerChanged", G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_connect_signal (manager->priv->bus_proxy, "NameOwnerChanged", G_CALLBACK (bus_name_owner_changed), manager, NULL); dbus_g_connection_register_g_object (manager->priv->connection, GSM_MANAGER_DBUS_PATH, G_OBJECT (manager)); return TRUE; }
PlayerProxies(Callback &callback) : // get the session connection dbus_sess_conn_(dbus_g_bus_get(DBUS_BUS_SESSION, NULL)), // get a proxy for the dbus service bus dbus_service_proxy_(dbus_g_proxy_new_for_name( dbus_sess_conn_, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS)), callback_(callback) { g_assert(dbus_sess_conn_); g_assert(dbus_service_proxy_); // specify argument signature for callback, might not be necessary dbus_g_proxy_add_signal( dbus_service_proxy_, "NameOwnerChanged", G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); // register callback to monitor for dbus connections dbus_g_proxy_connect_signal( dbus_service_proxy_, "NameOwnerChanged", G_CALLBACK(this->service_owner_changed), this, NULL); ppstore_.push_back(new RhythmboxProxy(dbus_sess_conn_, dbus_service_proxy_)); }
static void ovirtcred_server_start (GdmOVirtCredExtension *extension) { GError *error; g_debug ("Attempting listening to %s D-Bus interface...", GDM_OVIRTCRED_SERVER_DBUS_INTERFACE); error = NULL; extension->priv->connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error); if (extension->priv->connection == NULL) { if (error != NULL) { g_critical ("Error getting system bus: %s", error->message); g_error_free (error); } } extension->priv->cred_proxy = dbus_g_proxy_new_for_name (extension->priv->connection, GDM_OVIRTCRED_SERVER_DBUS_NAME, GDM_OVIRTCRED_SERVER_DBUS_PATH, GDM_OVIRTCRED_SERVER_DBUS_INTERFACE); if (extension->priv->cred_proxy == NULL) { g_warning ("error creating proxy"); } dbus_g_proxy_add_signal (extension->priv->cred_proxy, "UserAuthenticated", G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_connect_signal (extension->priv->cred_proxy, "UserAuthenticated", G_CALLBACK (on_user_authenticated), extension, NULL); }
gboolean rhythmbox_dbus_connect_to_bus (void) { g_type_init (); if (dbus_is_enabled ()) { dbus_proxy_player = create_new_session_proxy ( "org.gnome.Rhythmbox", "/org/gnome/Rhythmbox/Player", "org.gnome.Rhythmbox.Player" ); dbus_proxy_shell = create_new_session_proxy ( "org.gnome.Rhythmbox", "/org/gnome/Rhythmbox/Shell", "org.gnome.Rhythmbox.Shell" ); dbus_g_proxy_add_signal(dbus_proxy_player, "playingChanged", G_TYPE_BOOLEAN, G_TYPE_INVALID); dbus_g_proxy_add_signal(dbus_proxy_player, "playingUriChanged", G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_add_signal(dbus_proxy_player, "elapsedChanged", G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_add_signal(dbus_proxy_player, "rb:CovertArt-uri", G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_connect_signal(dbus_proxy_player, "playingChanged", G_CALLBACK(rb_onChangeState), NULL, NULL); dbus_g_proxy_connect_signal(dbus_proxy_player, "playingUriChanged", G_CALLBACK(rb_onChangeSong), NULL, NULL); dbus_g_proxy_connect_signal(dbus_proxy_player, "elapsedChanged", G_CALLBACK(rb_onElapsedChanged), NULL, NULL); dbus_g_proxy_connect_signal(dbus_proxy_player, "rb:CovertArt-uri", G_CALLBACK(rb_onCovertArtChanged), NULL, NULL); return TRUE; } return FALSE; }