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