int start_devicelock_listener(void)
{
DBusError err = DBUS_ERROR_INIT;
DBusConnection *dbus_conn_devicelock = NULL;
if( (dbus_conn_devicelock = dbus_bus_get(DBUS_BUS_SYSTEM, &err)) == 0 )
{
log_err("Could not connect to dbus for devicelock\n");
goto cleanup;
}
dbus_bus_add_match(dbus_conn_devicelock, MATCH_DEVICELOCK_SIGNALS, &err);
if( dbus_error_is_set(&err) )
{
goto cleanup;
}
if( !dbus_connection_add_filter(dbus_conn_devicelock, devicelock_unlocked_cb , 0, 0) )
{
log_err("adding system dbus filter for devicelock failed");
goto cleanup;
}
dbus_connection_setup_with_g_main(dbus_conn_devicelock, NULL);
cleanup:
dbus_error_free(&err);
return(1);
}
static int
vehicle_gpsd_dbus_open(struct vehicle_priv *priv)
{
DBusError error;
dbus_error_init(&error);
if (priv->address) {
priv->connection = dbus_connection_open(priv->address, &error);
} else {
priv->connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
}
if (!priv->connection) {
dbg(0,"Failed to open connection to %s message bus: %s\n", priv->address?priv->address:"session",error.message);
dbus_error_free(&error);
return 0;
}
dbus_connection_setup_with_g_main(priv->connection, NULL);
dbus_bus_add_match(priv->connection,"type='signal',interface='org.gpsd'",&error);
dbus_connection_flush(priv->connection);
if (dbus_error_is_set(&error)) {
dbg(0,"Failed to add match to connection: %s\n", error.message);
vehicle_gpsd_dbus_close(priv);
return 0;
}
if (!dbus_connection_add_filter(priv->connection, vehicle_gpsd_dbus_filter, priv, NULL)) {
dbg(0,"Failed to add filter to connection\n");
vehicle_gpsd_dbus_close(priv);
return 0;
}
return 1;
}
void VolumeBarLogic::openConnection (bool init)
{
/*
* Check the connection first, maybe this function
* only called because of lost connection
*/
if ((dbus_conn != NULL) && (dbus_connection_get_is_connected (dbus_conn)))
return;
DBusError dbus_err;
char *pa_bus_address = getenv ("PULSE_DBUS_SERVER");
if (pa_bus_address == NULL)
pa_bus_address = (char *) DEFAULT_ADDRESS;
dbus_error_init (&dbus_err);
dbus_conn = dbus_connection_open (pa_bus_address, &dbus_err);
DBUS_ERR_CHECK (dbus_err);
if (dbus_conn != NULL) {
dbus_connection_setup_with_g_main (dbus_conn, NULL);
dbus_connection_add_filter (
dbus_conn,
(DBusHandleMessageFunction) VolumeBarLogic::stepsUpdatedSignal,
(void *) this, NULL);
if (init == true)
initValues ();
}
}
static void
_new_connection (DBusServer *server,
DBusConnection *connection,
void *data)
{
ServiceData *svc = (ServiceData *)data;
DBusObjectPathVTable vt = {
_unregister_handler,
_handle_message,
NULL, NULL, NULL, NULL
};
rb_debug ("new connection to metadata service");
/* don't allow more than one connection at a time */
if (svc->connection) {
rb_debug ("metadata service already has a client. go away.");
return;
}
dbus_connection_register_object_path (connection,
RB_METADATA_DBUS_OBJECT_PATH,
&vt,
svc);
dbus_connection_ref (connection);
dbus_connection_setup_with_g_main (connection,
g_main_loop_get_context (svc->loop));
if (!svc->external)
dbus_connection_set_exit_on_disconnect (connection, TRUE);
}
int
main (int argc, char **argv)
{
GMainLoop *loop;
DBusConnection *bus;
DBusError error;
loop = g_main_loop_new (NULL, FALSE);
dbus_error_init (&error);
bus = dbus_bus_get (DBUS_BUS_SESSION, &error);
if (!bus) {
g_warning ("Failed to connect to the D-BUS daemon: %s", error.message);
dbus_error_free (&error);
return 1;
}
dbus_connection_setup_with_g_main (bus, NULL);
/* listening to messages from all objects as no path is specified */
dbus_bus_add_match (bus, "type='signal',interface='com.burtonini.dbus.Signal'", &error);
dbus_connection_add_filter (bus, signal_filter, loop, NULL);
g_main_loop_run (loop);
return 0;
}
static void
new_connection_cb (DBusServer * server,
DBusConnection* connection,
gpointer user_data)
{
dbus_int32_t slot = -1;
GObject * object;
if (!dbus_connection_allocate_data_slot (&slot))
{
g_warning ("error allocating data slot for DBusConnection");
dbus_connection_close (connection);
return;
}
dbus_connection_ref (connection);
dbus_connection_set_allow_anonymous (connection, TRUE);
dbus_connection_setup_with_g_main (connection, NULL);
object = g_object_new (p2p_object_get_type (), NULL);
dbus_g_connection_register_g_object (dbus_connection_get_g_connection (connection),
"/", object);
dbus_connection_set_data (connection, slot,
object, g_object_unref);
}
void* dbus_listen_for_signals(void* user_data)
{
DBusError error;
dbus_error_init(&error);
GMainContext* mainContext=g_main_context_new();
GMainLoop* loop = g_main_loop_new (mainContext, 0);
dbus_g_thread_init();
bus = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
if (bus == NULL) {
g_printerr("Failed to open connection to bus: %s", error.message);
dbus_error_free(&error);
return NULL;
}
dbus_connection_setup_with_g_main (bus, mainContext);
dbus_bus_add_match(bus, "interface='" SERVICE_NAME "'", &error);
if(dbus_connection_add_filter(bus, signal_filter, user_data, NULL)==FALSE)
qDebug("dbus_connection_add_filter returned false !\n");
g_main_loop_run(loop);
return NULL;
}
void pm_upower_init()
{
DBusError error;
dbus_error_init(&error);
DBusConnection *conn = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
if (dbus_error_is_set(&error)) {
g_error("Cannot get System BUS connection: %s", error.message);
dbus_error_free(&error);
return;
}
dbus_connection_setup_with_g_main(conn, NULL);
dbus_bus_add_match(conn, RULE, &error);
if (dbus_error_is_set(&error)) {
g_error("Cannot add D-BUS match rule, cause: %s", error.message);
dbus_error_free(&error);
return;
}
dbus_connection_add_filter(conn, signal_filter, NULL, NULL);
}
int
main ()
{
NotifyNotification *n;
DBusConnection *conn;
if (!notify_init ("Default Action Test"))
exit (1);
conn = dbus_bus_get (DBUS_BUS_SESSION, NULL);
loop = g_main_loop_new (NULL, FALSE);
dbus_connection_setup_with_g_main (conn, NULL);
n = notify_notification_new ("Matt is online", "", NULL, NULL);
notify_notification_set_timeout (n, NOTIFY_EXPIRES_DEFAULT);
notify_notification_add_action (n,
"default",
"Do Default Action",
(NotifyActionCallback) callback,
NULL,
NULL);
notify_notification_set_category (n, "presence.online");
if (!notify_notification_show (n, NULL)) {
fprintf (stderr, "failed to send notification\n");
return 1;
}
g_main_loop_run (loop);
return 0;
}
static void dbus_related(GMainLoop *loop)
{
DBusConnection *bus;
DBusError error;
dbus_error_init (&error);
bus = dbus_bus_get (DBUS_BUS_SESSION, &error);
if (!bus)
{
g_warning ("Failed to connect to the D-BUS daemon: %s", error.message);
dbus_error_free (&error);
return;
}
//dbus_bus_register(bus, NULL);
//dbus_bus_set_unique_name(bus, "org.freedesktop.program2");
/*注意这句话一定要有，这样才有公共名称！*/
dbus_bus_request_name(bus, "org.freedesktop.program2", DBUS_NAME_FLAG_ALLOW_REPLACEMENT, NULL);
dbus_connection_setup_with_g_main (bus, NULL);
/*添加消息信息*/
//dbus_bus_add_match (bus, "type='method_call',interface='org.freedesktop.program2',member='print', path='/org/freedesktop/program2',destination='org.freedesktop.program2'", NULL);
/*添加消息侦听函数*/
dbus_connection_add_filter (bus, signal_filter, loop, NULL);
g_main_loop_run (loop);
}
static int dbus_mainloop(void)
{
GMainLoop *mainloop;
DBusError error;
mainloop = g_main_loop_new(NULL, FALSE);
dbus_error_init(&error);
connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
if (dbus_error_is_set(&error)) {
syslog(LOG_CRIT, "%s: %s", error.name, error.message);
return 3;
}
dbus_bus_add_match(connection, "type='signal'", &error);
if (dbus_error_is_set(&error)) {
syslog(LOG_CRIT, "unable to add match for signals %s: %s", error.name,
error.message);
return 4;
}
if (!dbus_connection_add_filter
(connection, (DBusHandleMessageFunction) signal_handler, NULL,
NULL)) {
syslog(LOG_CRIT, "unable to register filter with the connection");
return 5;
}
dbus_connection_setup_with_g_main(connection, NULL);
print_gpx_header();
g_main_loop_run(mainloop);
return 0;
}
/**
* wrapper_init:
*
* Acquires connection to the session bus and initializes source and renderer
* wrappers.
*/
void wrapper_init(void)
{
DBusError err;
dbus_error_init(&err);
Session_bus = dbus_bus_get(DBUS_BUS_SESSION, &err);
if (dbus_error_is_set(&err)) {
g_critical("wrapper_init(): %s",
dbus_error_is_set(&err) ? err.message : "error");
dbus_error_free(&err);
exit(2);
}
dbus_connection_setup_with_g_main(Session_bus, NULL);
g_signal_connect(mafw_registry_get_instance(), "source-added",
G_CALLBACK(registry_action),
GUINT_TO_POINTER(EXTENSION_ADDED));
g_signal_connect(mafw_registry_get_instance(), "source-removed",
G_CALLBACK(registry_action),
GUINT_TO_POINTER(EXTENSION_REMOVED));
g_signal_connect(mafw_registry_get_instance(), "renderer-added",
G_CALLBACK(registry_action),
GUINT_TO_POINTER(EXTENSION_ADDED));
g_signal_connect(mafw_registry_get_instance(), "renderer-removed",
G_CALLBACK(registry_action),
GUINT_TO_POINTER(EXTENSION_REMOVED));
extension_init(Session_bus);
}
static DBusConnection *
xdbus_init(void)
{
DBusError err = DBUS_ERROR_INIT;
DBusBusType bus_type = DBUS_BUS_SYSTEM;
if( xdbus_con )
goto EXIT;
if( !(xdbus_con = dbus_bus_get(bus_type, &err)) ) {
log_error("Failed to open connection to message bus"
"; %s: %s", err.name, err.message);
goto EXIT;
}
dbus_connection_setup_with_g_main(xdbus_con, 0);
dbus_connection_add_filter(xdbus_con, xdbus_filter_cb, 0, 0);
dbus_bus_add_match(xdbus_con, mce_display_ind_rule, 0);
log_debug("connected to system bus");
EXIT:
dbus_error_free(&err);
return xdbus_con;
}
gboolean
gconfd_dbus_init (void)
{
DBusError error;
gint ret;
dbus_error_init (&error);
bus_conn = dbus_bus_get (DBUS_BUS_SESSION, &error);
if (!bus_conn)
{
gconf_log (GCL_ERR, _("Daemon failed to connect to the D-BUS daemon:\n%s"),
error.message);
dbus_error_free (&error);
return FALSE;
}
/* We handle exiting ourselves on disconnect. */
dbus_connection_set_exit_on_disconnect (bus_conn, FALSE);
/* Add message filter to handle Disconnected. */
dbus_connection_add_filter (bus_conn,
(DBusHandleMessageFunction) server_filter_func,
NULL, NULL);
ret = dbus_bus_request_name (bus_conn,
GCONF_DBUS_SERVICE,
0,
&error);
if (ret != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
{
gconf_log (GCL_ERR, "Daemon could not become primary owner");
return FALSE;
}
if (dbus_error_is_set (&error))
{
gconf_log (GCL_ERR, _("Daemon failed to acquire gconf service:\n%s"),
error.message);
dbus_error_free (&error);
return FALSE;
}
if (!dbus_connection_register_object_path (bus_conn,
server_path,
&server_vtable,
NULL))
{
gconf_log (GCL_ERR, _("Failed to register server object with the D-BUS bus daemon"));
return FALSE;
}
nr_of_connections = 1;
dbus_connection_setup_with_g_main (bus_conn, NULL);
return TRUE;
}
void plugin_init(void)
{
DBusError error;
object_hash=g_hash_table_new(g_str_hash, g_str_equal);
object_count=g_hash_table_new(g_str_hash, g_str_equal);
dbg(0,"enter 1\n");
dbus_error_init(&error);
connection = dbus_bus_get(DBUS_BUS_SESSION, &error);
if (!connection) {
dbg(0,"Failed to open connection to session message bus: %s\n", error.message);
dbus_error_free(&error);
return;
}
dbus_connection_setup_with_g_main(connection, NULL);
#if 0
dbus_connection_add_filter(connection, filter, NULL, NULL);
dbus_bus_add_match(connection, "type='signal',""interface='" DBUS_INTERFACE_DBUS "'", &error);
#endif
dbus_connection_register_fallback(connection, object_path, &dbus_navit_vtable, NULL);
dbus_bus_request_name(connection, service_name, 0, &error);
if (dbus_error_is_set(&error)) {
dbg(0,"Failed to request name: %s", error.message);
dbus_error_free (&error);
}
}
static gboolean
init_dbus ()
{
DBusError error;
dbus_error_init (&error);
bus = dbus_bus_get (DBUS_BUS_SYSTEM, &error);
dbus_connection_setup_with_g_main (bus, NULL);
if (dbus_error_is_set (&error)) {
g_error ("Net Monitor: Couldn't connect to system bus : %s: %s\n", error.name, error.message);
return FALSE;
}
dbus_connection_add_filter (bus, filter_func, NULL, NULL);
dbus_bus_add_match (bus, "type='signal',interface='" NM_INTERFACE "'", &error);
if (dbus_error_is_set (&error)) {
g_error ("Net Monitor: Could not register signal handler: %s: %s\n", error.name, error.message);
return FALSE;
}
return TRUE;
}
static void
new_connection_callback (DBusServer *server,
DBusConnection *new_connection,
void *user_data)
{
ThreadTestData * data;
g_print ("new_connection_callback\n");
dbus_connection_ref (new_connection);
dbus_connection_setup_with_g_main (new_connection, NULL);
data = thread_test_data_new ();
if (!dbus_connection_add_filter (new_connection,
filter_test_message, data,
(DBusFreeFunction) thread_test_data_free))
goto nomem;
if (!dbus_connection_add_filter (new_connection,
filter_disconnect, NULL, NULL))
goto nomem;
return;
nomem:
g_error ("no memory to setup new connection");
}
static gboolean
connect_peer_to_peer()
{
DBusError error;
dbus_error_init (&error);
volume_bus = dbus_connection_open (volume_pulse_address, &error);
if (dbus_error_is_set (&error)) {
N_WARNING (LOG_CAT "failed to open connection to pulseaudio: %s",
error.message);
dbus_error_free (&error);
return FALSE;
}
dbus_connection_setup_with_g_main (volume_bus, NULL);
if (!dbus_connection_add_filter (volume_bus, filter_cb, NULL, NULL)) {
N_WARNING (LOG_CAT "failed to add filter");
return FALSE;
}
process_queued_ops();
return TRUE;
}
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);
}
int
main (int argc, char *argv[])
{
DBusConnection *dbus_connection;
DBusError error;
const char *commandline;
hal_set_proc_title_init (argc, argv);
setup_logger ();
dbus_error_init (&error);
if ((ctx = libhal_ctx_init_direct (&error)) == NULL) {
HAL_WARNING (("Unable to init libhal context"));
goto out;
}
if ((dbus_connection = libhal_ctx_get_dbus_connection(ctx)) == NULL) {
HAL_WARNING (("Cannot get DBus connection"));
goto out;
}
if ((commandline = getenv ("SINGLETON_COMMAND_LINE")) == NULL) {
HAL_WARNING (("SINGLETON_COMMAND_LINE not set"));
goto out;
}
libhal_ctx_set_singleton_device_added (ctx, add_device);
libhal_ctx_set_singleton_device_removed (ctx, remove_device);
dbus_connection_setup_with_g_main (dbus_connection, NULL);
dbus_connection_set_exit_on_disconnect (dbus_connection, 0);
if (!libhal_device_singleton_addon_is_ready (ctx, commandline, &error)) {
goto out;
}
leds = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
gmain = g_main_loop_new (NULL, FALSE);
g_main_loop_run (gmain);
return 0;
out:
HAL_DEBUG (("An error occured, exiting cleanly"));
LIBHAL_FREE_DBUS_ERROR (&error);
if (ctx != NULL) {
libhal_ctx_shutdown (ctx, &error);
LIBHAL_FREE_DBUS_ERROR (&error);
libhal_ctx_free (ctx);
}
return 0;
}
static dbus_bool_t
dbus_py_glib_set_up_conn(DBusConnection *conn, void *data)
{
GMainContext *ctx = (GMainContext *)data;
Py_BEGIN_ALLOW_THREADS
dbus_connection_setup_with_g_main(conn, ctx);
Py_END_ALLOW_THREADS
return 1;
}
static int
init_dbus(DBusError *error)
{
if (!(dbus_conn = dbus_bus_get(DBUS_BUS_SYSTEM, error)))
return -1;
dbus_connection_setup_with_g_main(dbus_conn, (GMainContext *)NULL);
dbus_connection_flush(dbus_conn);
return 0;
}
static LassiConnection* connection_add(LassiServer *ls, DBusConnection *c, gboolean we_are_client) {
LassiConnection *lc;
dbus_bool_t b;
DBusMessage *m;
gint32 ag, og, cg;
int fd, one = 1;
g_assert(ls);
g_assert(c);
lc = g_new(LassiConnection, 1);
lc->dbus_connection = dbus_connection_ref(c);
lc->server = ls;
lc->id = lc->address = NULL;
lc->we_are_client = we_are_client;
lc->delayed_welcome = FALSE;
ls->connections = g_list_prepend(ls->connections, lc);
ls->n_connections++;
dbus_connection_setup_with_g_main(c, NULL);
b = dbus_connection_add_filter(c, message_function, lc, NULL);
g_assert(b);
m = dbus_message_new_signal("/", LASSI_INTERFACE, "Hello");
g_assert(m);
ag = ls->active_generation;
og = ls->order_generation;
cg = ls->clipboard_generation;
b = dbus_message_append_args(
m,
DBUS_TYPE_STRING, &ls->id,
DBUS_TYPE_STRING, &ls->address,
DBUS_TYPE_INT32, &ag,
DBUS_TYPE_INT32, &og,
DBUS_TYPE_INT32, &cg,
DBUS_TYPE_INVALID);
g_assert(b);
fd = -1;
dbus_connection_get_socket(c, &fd);
g_assert(fd >= 0);
if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one)) < 0)
g_warning("Failed to enable TCP_NODELAY");
b = dbus_connection_send(c, m, NULL);
g_assert(b);
dbus_message_unref(m);
lassi_tray_update(&ls->tray_info, ls->n_connections);
return lc;
}
static void
set_reply (DBusPendingCall * pending, void *user_data)
{
SpiReentrantCallClosure* closure = (SpiReentrantCallClosure *) user_data;
closure->reply = dbus_pending_call_steal_reply (pending);
dbus_connection_setup_with_g_main (bus, NULL);
g_main_loop_quit (closure->loop);
}
static void
setup_hal_devices (void)
{
DBusConnection *connection;
DBusError error;
LibHalContext *ctx;
char **devices;
int i, num = 0;
dbus_error_init (&error);
connection = dbus_bus_get (DBUS_BUS_SYSTEM, &error);
if (connection == NULL) {
/* cannot get a dbus connection */
if (dbus_error_is_set (&error)) {
g_warning ("Getting a system dbus connection an error occured: %s", error.message);
dbus_error_free (&error);
}
return;
}
dbus_connection_setup_with_g_main (connection, g_main_context_default ());
ctx = libhal_ctx_new ();
g_return_if_fail (ctx != NULL);
libhal_ctx_set_device_added (ctx, device_added_callback);
libhal_ctx_set_device_removed (ctx, device_removed_callback);
libhal_ctx_set_dbus_connection (ctx, connection);
if (!libhal_ctx_init (ctx, &error)) {
/* cannot connect to hald */
if (dbus_error_is_set (&error)) {
g_warning ("Connecting to hald an error occured: %s", error.message);
dbus_error_free (&error);
}
return;
}
devices = libhal_find_device_by_capability (ctx, "alsa", &num, &error);
if (devices == NULL) {
/* error in the libhal_find_device_by_capability function */
if (dbus_error_is_set (&error)) {
g_warning ("Calling a hal function an error occured: %s", error.message);
dbus_error_free (&error);
}
return;
}
for (i = 0; i < num; i++) {
device_added_callback (ctx, devices[i]);
}
dbus_free_string_array (devices);
}
static DBusMessage *
send_and_allow_reentry (DBusConnection * bus, DBusMessage * message)
{
DBusPendingCall *pending;
SpiReentrantCallClosure closure;
closure.loop = g_main_loop_new (main_context, FALSE);
dbus_connection_setup_with_g_main (bus, main_context);
if (!dbus_connection_send_with_reply (bus, message, &pending, 3000))
{
dbus_connection_setup_with_g_main (bus, NULL);
return NULL;
}
dbus_pending_call_set_notify (pending, set_reply, (void *) &closure, NULL);
g_main_loop_run (closure.loop);
g_main_loop_unref (closure.loop);
return closure.reply;
}
void dbus_init()
{
DBusError err;
dbus_error_init(&err);
dbus = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
if (!dbus) {
syslog(LOG_ERR, "Failed to connect to D-BUS daemon: %s.\n", err.message);
dbus_error_free(&err);
}
dbus_connection_setup_with_g_main(dbus, NULL);
}
static void
setup (Test *test,
gconstpointer data)
{
GError *error = NULL;
GQuark features[] = { TP_CONNECTION_FEATURE_CONNECTED, 0 };
tp_debug_set_flags ("all");
test->dbus = tp_tests_dbus_daemon_dup_or_die ();
test->mainloop = g_main_loop_new (NULL, FALSE);
test->error = NULL;
test->client_libdbus = dbus_bus_get_private (DBUS_BUS_STARTER, NULL);
g_assert (test->client_libdbus != NULL);
dbus_connection_setup_with_g_main (test->client_libdbus, NULL);
dbus_connection_set_exit_on_disconnect (test->client_libdbus, FALSE);
test->client_dbusglib = dbus_connection_get_g_connection (
test->client_libdbus);
dbus_g_connection_ref (test->client_dbusglib);
test->client_bus = tp_dbus_daemon_new (test->client_dbusglib);
g_assert (test->client_bus != NULL);
test->service_conn = tp_tests_object_new_static_class (
EXAMPLE_TYPE_CONTACT_LIST_CONNECTION,
"account", "*****@*****.**",
"protocol", "simple-protocol",
NULL);
test->service_conn_as_base = TP_BASE_CONNECTION (test->service_conn);
g_assert (test->service_conn != NULL);
g_assert (test->service_conn_as_base != NULL);
g_assert (tp_base_connection_register (test->service_conn_as_base, "simple",
&test->conn_name, &test->conn_path, &error));
g_assert_no_error (error);
test->cwr_ready = FALSE;
test->cwr_error = NULL;
test->conn = tp_connection_new (test->client_bus, test->conn_name,
test->conn_path, &error);
g_assert (test->conn != NULL);
g_assert_no_error (error);
tp_cli_connection_call_connect (test->conn, -1, NULL, NULL, NULL, NULL);
g_assert (!tp_proxy_is_prepared (test->conn, TP_CONNECTION_FEATURE_CORE));
g_assert (!tp_proxy_is_prepared (test->conn,
TP_CONNECTION_FEATURE_CONNECTED));
g_assert (!tp_proxy_is_prepared (test->conn, TP_CONNECTION_FEATURE_BALANCE));
tp_tests_proxy_run_until_prepared (test->conn, features);
}
RZLWidget::RZLWidget(QWidget *parent) : QWidget(parent) {
setAttribute(Qt::WA_TranslucentBackground);
icon_unklar = new QIcon("/usr/share/raumzeitlabor-status-widget/unklar.png");
icon_auf = new QIcon("/usr/share/raumzeitlabor-status-widget/auf.png");
icon_zu = new QIcon("/usr/share/raumzeitlabor-status-widget/zu.png");
icon = icon_unklar;
lastUpdated = "?";
hdl = curl_easy_init();
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "Pragma: no-cache");
headers = curl_slist_append(headers, "Cache-Control: no-cache");
curl_easy_setopt(hdl, CURLOPT_URL, "http://status.raumzeitlabor.de/api/simple");
curl_easy_setopt(hdl, CURLOPT_HTTPHEADER, headers);
curl_easy_setopt(hdl, CURLOPT_WRITEFUNCTION, recv_status);
curl_easy_setopt(hdl, CURLOPT_WRITEDATA, this);
curl_easy_setopt(hdl, CURLOPT_ERRORBUFFER, errbuf);
/* set a timeout of 30 seconds */
curl_easy_setopt(hdl, CURLOPT_TIMEOUT, 30);
/* Timer will be triggered in setConnection() as soon as the connection
* status is known */
timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), this, SLOT(trigger_update()));
periodic_bearer = new QTimer(this);
periodic_bearer->start(60 * 1000);
connect(periodic_bearer, SIGNAL(timeout()), this, SLOT(trigger_periodic()));
/* Setup stuff for the conic library */
DBusConnection *conn;
DBusError err;
dbus_error_init(&err);
conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err);
if (!conn)
return;
dbus_connection_setup_with_g_main(conn, NULL);
/* We want to get called on connection events */
connection = con_ic_connection_new();
g_signal_connect(G_OBJECT(connection), "connection-event", G_CALLBACK(connection_change), this);
g_object_set(G_OBJECT(connection), "automatic-connection-events", TRUE, NULL);
/* ConIcConnection object named "connection" has already been created */
g_signal_connect(G_OBJECT(connection), "statistics", G_CALLBACK(connection_statistics), this);
con_ic_connection_statistics(connection, NULL);
}
int
main (int argc,
char **argv)
{
int ret;
DBusConnection *bus;
DBusMessage *msg;
DBusError err = {0};
gtk_init (&argc, &argv);
bus = dbus_bus_get (DBUS_BUS_SESSION, &err);
if (dbus_error_is_set (&err))
goto exit;
ret = dbus_bus_request_name (bus, "org.gnome.ScreenshotGrabber",
DBUS_NAME_FLAG_DO_NOT_QUEUE, &err);
if (dbus_error_is_set (&err))
goto exit;
if (ret != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
{
msg = dbus_message_new_signal ("/org/gnome/ScreenshotGrabber",
"org.gnome.ScreenshotGrabber",
"take_screenshot");
dbus_connection_send (bus, msg, NULL);
dbus_message_unref (msg);
return 0;
}
dbus_connection_setup_with_g_main (bus, NULL);
dbus_bus_add_match (bus, "type='signal',"
"interface='org.gnome.ScreenshotGrabber',"
"path='/org/gnome/ScreenshotGrabber'", &err);
if (dbus_error_is_set (&err))
goto exit;
dbus_connection_add_filter (bus, dbus_handler, NULL, NULL);
take_screenshot ();
gtk_main ();
exit:
if (dbus_error_is_set (&err))
{
fprintf (stderr, "[E] DBus: %s\n", err.message);
dbus_error_free (&err);
}
return 0;
}
