fdo-mirrors/upower
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/upower/upower.git synced 2026-01-11 07:10:13 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

daemon: port UpDaemon to GDBus

Browse source
This commit is contained in:
Cosimo Cecchi 2015-05-30 12:32:39 -07:00 • committed by Richard Hughes
parent da7324a840
commit e7e9156fe9
3 changed files with 96 additions and 352 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
src/Makefile.am
View file

@ -36,8 +36,9 @@ AM_CPPFLAGS = \
UPOWER_LIBS = $(top_builddir)/libupower-glib/libupower-glib.la
BUILT_SOURCES = \
up-daemon-glue.h \
up-device-glue.h \
up-daemon-generated.h \
up-daemon-generated.c \
up-kbd-backlight-generated.h \
up-kbd-backlight-generated.c \
up-wakeups-generated.h \
@ -51,8 +52,12 @@ up-marshal.h: up-marshal.list
up-marshal.c: up-marshal.list
echo "#include \"up-marshal.h\"" > $@ && glib-genmarshal $< --prefix=up_marshal --body >> $@
up-daemon-glue.h: org.freedesktop.UPower.xml Makefile.am
dbus-binding-tool --prefix=up_daemon --mode=glib-server --output=up-daemon-glue.h $(srcdir)/org.freedesktop.UPower.xml
up-daemon-generated.h: org.freedesktop.UPower.xml Makefile.am
$(AM_V_GEN) gdbus-codegen --interface-prefix org.freedesktop.UPower. \
--generate-c-code up-daemon-generated \
--c-namespace Up \
--annotate "org.freedesktop.UPower" "org.gtk.GDBus.C.Name" ExportedDaemon \
$(srcdir)/org.freedesktop.UPower.xml
up-device-glue.h: org.freedesktop.UPower.Device.xml Makefile.am
dbus-binding-tool --prefix=up_device --mode=glib-server --output=up-device-glue.h $(srcdir)/org.freedesktop.UPower.Device.xml

420
src/up-daemon.c
View file

@ -29,8 +29,6 @@
#include <glib.h>
#include <glib/gi18n-lib.h>
#include <glib-object.h>
#include <dbus/dbus-glib.h>
#include <dbus/dbus-glib-lowlevel.h>
#include "up-config.h"
#include "up-device-list.h"
@ -38,32 +36,13 @@
#include "up-backend.h"
#include "up-daemon.h"
#include "up-daemon-glue.h"
#include "up-daemon-generated.h"
#include "up-marshal.h"
enum
{
PROP_0,
PROP_DAEMON_VERSION,
PROP_ON_BATTERY,
PROP_LID_IS_CLOSED,
PROP_LID_IS_PRESENT,
PROP_LAST
};
enum
{
SIGNAL_DEVICE_ADDED,
SIGNAL_DEVICE_REMOVED,
SIGNAL_LAST,
};
static guint signals[SIGNAL_LAST] = { 0 };
struct UpDaemonPrivate
{
DBusGConnection *connection;
DBusGProxy *proxy;
GDBusConnection *connection;
UpExportedDaemon *skeleton;
UpConfig *config;
UpBackend *backend;
UpDeviceList *power_devices;
@ -72,14 +51,7 @@ struct UpDaemonPrivate
GHashTable *idle_signals;
/* Properties */
gboolean on_battery;
UpDeviceLevel warning_level;
gboolean lid_is_closed;
gboolean lid_is_present;
/* PropertiesChanged to be emitted */
GHashTable *changed_props;
guint props_idle_id;
/* Display battery properties */
UpDevice *display_device;
@ -112,6 +84,7 @@ G_DEFINE_TYPE (UpDaemon, up_daemon, G_TYPE_OBJECT)
#define UP_DAEMON_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), UP_TYPE_DAEMON, UpDaemonPrivate))
#define UP_DAEMON_ACTION_DELAY 20 /* seconds */
#define UP_INTERFACE_PREFIX "org.freedesktop.UPower."
/**
* up_daemon_get_on_battery_local:
@ -417,8 +390,10 @@ up_daemon_refresh_battery_devices (UpDaemon *daemon)
/**
* up_daemon_enumerate_devices:
**/
gboolean
up_daemon_enumerate_devices (UpDaemon *daemon, DBusGMethodInvocation *context)
static gboolean
up_daemon_enumerate_devices (UpExportedDaemon *skeleton,
GDBusMethodInvocation *invocation,
UpDaemon *daemon)
{
guint i;
GPtrArray *array;
@ -428,14 +403,16 @@ up_daemon_enumerate_devices (UpDaemon *daemon, DBusGMethodInvocation *context)
/* build a pointer array of the object paths */
object_paths = g_ptr_array_new_with_free_func (g_free);
array = up_device_list_get_array (daemon->priv->power_devices);
for (i=0; i<array->len; i++) {
for (i = 0; i < array->len; i++) {
device = (UpDevice *) g_ptr_array_index (array, i);
g_ptr_array_add (object_paths, g_strdup (up_device_get_object_path (device)));
}
g_ptr_array_unref (array);
g_ptr_array_add (object_paths, NULL);
/* return it on the bus */
dbus_g_method_return (context, object_paths);
up_exported_daemon_complete_enumerate_devices (skeleton, invocation,
(const gchar **) object_paths->pdata);
/* free */
g_ptr_array_unref (object_paths);
@ -445,22 +422,26 @@ up_daemon_enumerate_devices (UpDaemon *daemon, DBusGMethodInvocation *context)
/**
* up_daemon_get_display_device:
**/
gboolean
up_daemon_get_display_device (UpDaemon *daemon,
DBusGMethodInvocation *context)
static gboolean
up_daemon_get_display_device (UpExportedDaemon *skeleton,
GDBusMethodInvocation *invocation,
UpDaemon *daemon)
{
dbus_g_method_return (context, up_device_get_object_path (daemon->priv->display_device));
up_exported_daemon_complete_get_display_device (skeleton, invocation,
up_device_get_object_path (daemon->priv->display_device));
return TRUE;
}
/**
* up_daemon_get_critical_action:
**/
gboolean
up_daemon_get_critical_action (UpDaemon *daemon,
DBusGMethodInvocation *context)
static gboolean
up_daemon_get_critical_action (UpExportedDaemon *skeleton,
GDBusMethodInvocation *invocation,
UpDaemon *daemon)
{
dbus_g_method_return (context, up_backend_get_critical_action (daemon->priv->backend));
up_exported_daemon_complete_get_display_device (skeleton, invocation,
up_backend_get_critical_action (daemon->priv->backend));
return TRUE;
}
@ -471,37 +452,31 @@ static gboolean
up_daemon_register_power_daemon (UpDaemon *daemon)
{
GError *error = NULL;
gboolean ret = FALSE;
UpDaemonPrivate *priv = daemon->priv;
priv->connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
if (priv->connection == NULL) {
if (error != NULL) {
g_critical ("error getting system bus: %s", error->message);
g_error_free (error);
}
goto out;
priv->connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
if (error != NULL) {
g_critical ("error getting system bus: %s", error->message);
g_error_free (error);
return FALSE;
}
/* export our interface on the bus */
g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (priv->skeleton),
connection,
"/org/freedesktop/UPower",
&error);
if (error != NULL) {
g_critical ("error registering daemon on system bus: %s", error->message);
g_error_free (error);
return FALSE;
}
/* Register the display device */
up_device_register_display_device (daemon->priv->display_device,
daemon);
up_device_register_display_device (daemon->priv->display_device, daemon);
/* connect to DBUS */
priv->proxy = dbus_g_proxy_new_for_name (priv->connection,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS);
/* register GObject */
dbus_g_connection_register_g_object (priv->connection,
"/org/freedesktop/UPower",
G_OBJECT (daemon));
/* success */
ret = TRUE;
out:
return ret;
return TRUE;
}
/**
@ -515,7 +490,13 @@ up_daemon_startup (UpDaemon *daemon)
UpDeviceLevel warning_level;
UpDaemonPrivate *priv = daemon->priv;
/* stop signals and callbacks */
/* register on bus */
ret = up_daemon_register_power_daemon (daemon, connection);
if (!ret) {
g_warning ("failed to register");
goto out;
}
g_debug ("daemon now coldplug");
/* coldplug backend backend */
@ -532,16 +513,8 @@ up_daemon_startup (UpDaemon *daemon)
up_daemon_set_on_battery (daemon, on_battery);
up_daemon_set_warning_level (daemon, warning_level);
/* start signals and callbacks */
g_debug ("daemon now not coldplug");
/* register on bus */
ret = up_daemon_register_power_daemon (daemon);
if (!ret) {
g_warning ("failed to register");
goto out;
}
out:
return ret;
}
@ -573,132 +546,6 @@ up_daemon_get_device_list (UpDaemon *daemon)
return g_object_ref (daemon->priv->power_devices);
}
static void
changed_props_add_to_msg (gpointer key,
gpointer _value,
gpointer user_data)
{
GVariant *value = _value;
const gchar *property = key;
DBusMessageIter *subiter = user_data;
DBusMessageIter v_iter;
DBusMessageIter dict_iter;
dbus_message_iter_open_container (subiter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_iter);
dbus_message_iter_append_basic (&dict_iter, DBUS_TYPE_STRING, &property);
if (g_variant_is_of_type (value, G_VARIANT_TYPE_UINT32)) {
guint32 val = g_variant_get_uint32 (value);
dbus_message_iter_open_container (&dict_iter, DBUS_TYPE_VARIANT, "u", &v_iter);
dbus_message_iter_append_basic (&v_iter, DBUS_TYPE_UINT32, &val);
} else if (g_variant_is_of_type (value, G_VARIANT_TYPE_BOOLEAN)) {
gboolean val = g_variant_get_boolean (value);
dbus_message_iter_open_container (&dict_iter, DBUS_TYPE_VARIANT, "b", &v_iter);
dbus_message_iter_append_basic (&v_iter, DBUS_TYPE_BOOLEAN, &val);
} else if (g_variant_is_of_type (value, G_VARIANT_TYPE_STRING)) {
const gchar *val = g_variant_get_string (value, NULL);
dbus_message_iter_open_container (&dict_iter, DBUS_TYPE_VARIANT, "s", &v_iter);
dbus_message_iter_append_basic (&v_iter, DBUS_TYPE_STRING, &val);
} else if (g_variant_is_of_type (value, G_VARIANT_TYPE_DOUBLE)) {
gdouble val = g_variant_get_double (value);
dbus_message_iter_open_container (&dict_iter, DBUS_TYPE_VARIANT, "d", &v_iter);
dbus_message_iter_append_basic (&v_iter, DBUS_TYPE_DOUBLE, &val);
} else if (g_variant_is_of_type (value, G_VARIANT_TYPE_UINT64)) {
guint64 val = g_variant_get_uint64 (value);
dbus_message_iter_open_container (&dict_iter, DBUS_TYPE_VARIANT, "t", &v_iter);
dbus_message_iter_append_basic (&v_iter, DBUS_TYPE_UINT64, &val);
} else if (g_variant_is_of_type (value, G_VARIANT_TYPE_INT64)) {
gint64 val = g_variant_get_int64 (value);
dbus_message_iter_open_container (&dict_iter, DBUS_TYPE_VARIANT, "x", &v_iter);
dbus_message_iter_append_basic (&v_iter, DBUS_TYPE_INT64, &val);
} else {
g_assert_not_reached ();
}
dbus_message_iter_close_container (&dict_iter, &v_iter);
dbus_message_iter_close_container (subiter, &dict_iter);
}
void
up_daemon_emit_properties_changed (DBusGConnection *gconnection,
const gchar *object_path,
const gchar *interface,
GHashTable *props)
{
DBusConnection *connection;
DBusMessage *message;
DBusMessageIter iter;
DBusMessageIter subiter;
g_return_if_fail (gconnection != NULL);
g_return_if_fail (object_path != NULL);
g_return_if_fail (interface != NULL);
g_return_if_fail (props != NULL);
connection = dbus_g_connection_get_connection (gconnection);
message = dbus_message_new_signal (object_path,
"org.freedesktop.DBus.Properties",
"PropertiesChanged");
dbus_message_iter_init_append (message, &iter);
dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &interface);
/* changed */
dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "{sv}", &subiter);
g_hash_table_foreach (props, changed_props_add_to_msg, &subiter);
dbus_message_iter_close_container (&iter, &subiter);
/* invalidated */
dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY, "s", &subiter);
dbus_message_iter_close_container (&iter, &subiter);
dbus_connection_send (connection, message, NULL);
dbus_message_unref (message);
}
static gboolean
changed_props_idle_cb (gpointer user_data)
{
UpDaemon *daemon = user_data;
/* D-Bus */
up_daemon_emit_properties_changed (daemon->priv->connection,
"/org/freedesktop/UPower",
"org.freedesktop.UPower",
daemon->priv->changed_props);
g_clear_pointer (&daemon->priv->changed_props, g_hash_table_unref);
daemon->priv->props_idle_id = 0;
return G_SOURCE_REMOVE;
}
/**
* up_daemon_queue_changed_property:
**/
static void
up_daemon_queue_changed_property (UpDaemon *daemon,
const gchar *property,
GVariant *value)
{
g_return_if_fail (UP_IS_DAEMON (daemon));
if (daemon->priv->connection == NULL) {
g_variant_unref (value);
return;
}
if (!daemon->priv->changed_props) {
daemon->priv->changed_props = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL, (GDestroyNotify) g_variant_unref);
}
g_hash_table_insert (daemon->priv->changed_props,
(gpointer) property,
value);
if (daemon->priv->props_idle_id == 0)
daemon->priv->props_idle_id = g_idle_add (changed_props_idle_cb, daemon);
}
/**
* up_daemon_set_lid_is_closed:
**/
@ -714,10 +561,7 @@ up_daemon_set_lid_is_closed (UpDaemon *daemon, gboolean lid_is_closed)
}
g_debug ("lid_is_closed = %s", lid_is_closed ? "yes" : "no");
priv->lid_is_closed = lid_is_closed;
g_object_notify (G_OBJECT (daemon), "lid-is-closed");
up_daemon_queue_changed_property (daemon, "LidIsClosed", g_variant_new_boolean (lid_is_closed));
up_exported_daemon_set_lid_is_closed (priv->skeleton, lid_is_closed);
}
/**
@ -735,10 +579,7 @@ up_daemon_set_lid_is_present (UpDaemon *daemon, gboolean lid_is_present)
}
g_debug ("lid_is_present = %s", lid_is_present ? "yes" : "no");
priv->lid_is_present = lid_is_present;
g_object_notify (G_OBJECT (daemon), "lid-is-present");
up_daemon_queue_changed_property (daemon, "LidIsPresent", g_variant_new_boolean (lid_is_present));
up_exported_daemon_set_lid_is_present (priv->skeleton, lid_is_present);
}
/**
@ -749,10 +590,7 @@ up_daemon_set_on_battery (UpDaemon *daemon, gboolean on_battery)
{
UpDaemonPrivate *priv = daemon->priv;
g_debug ("on_battery = %s", on_battery ? "yes" : "no");
priv->on_battery = on_battery;
g_object_notify (G_OBJECT (daemon), "on-battery");
up_daemon_queue_changed_property (daemon, "OnBattery", g_variant_new_boolean (on_battery));
up_exported_daemon_set_on_battery (priv->skeleton, on_battery);
}
static gboolean
@ -862,9 +700,8 @@ up_daemon_update_warning_level (UpDaemon *daemon)
/* Check if the on_battery and warning_level state has changed */
ret = (up_daemon_get_on_battery_local (daemon) && !up_daemon_get_on_ac_local (daemon));
if (ret != priv->on_battery) {
up_daemon_set_on_battery (daemon, ret);
}
up_daemon_set_on_battery (daemon, ret);
warning_level = up_daemon_get_warning_level_local (daemon);
if (warning_level != priv->warning_level)
up_daemon_set_warning_level (daemon, warning_level);
@ -1071,7 +908,7 @@ up_daemon_device_added_cb (UpBackend *backend, GObject *native, UpDevice *device
g_warning ("INTERNAL STATE CORRUPT (device-added): not sending NULL, native:%p, device:%p", native, device);
return;
}
g_signal_emit (daemon, signals[SIGNAL_DEVICE_ADDED], 0, object_path);
up_exported_daemon_emit_device_added (daemon->priv->skeleton, object_path);
}
/**
@ -1099,7 +936,7 @@ up_daemon_device_removed_cb (UpBackend *backend, GObject *native, UpDevice *devi
g_warning ("INTERNAL STATE CORRUPT (device-removed): not sending NULL, native:%p, device:%p", native, device);
return;
}
g_signal_emit (daemon, signals[SIGNAL_DEVICE_REMOVED], 0, object_path);
up_exported_daemon_emit_device_removed (daemon->priv->skeleton, object_path);
/* finalise the object */
g_object_unref (device);
@ -1176,68 +1013,37 @@ up_daemon_init (UpDaemon *daemon)
daemon->priv->poll_timeouts = g_hash_table_new_full (g_direct_hash, g_direct_equal,
NULL, g_free);
daemon->priv->idle_signals = g_hash_table_new (g_direct_hash, g_direct_equal);
daemon->priv->skeleton = up_exported_daemon_skeleton_new ();
up_exported_daemon_set_daemon_version (daemon->priv->skeleton, PACKAGE_VERSION);
g_signal_connect (daemon->priv->skeleton, "handle-enumerate-devices",
G_CALLBACK (up_daemon_enumerate_devices), daemon);
g_signal_connect (daemon->priv->skeleton, "handle-get-critical-action",
G_CALLBACK (up_daemon_get_critical_action), daemon);
g_signal_connect (daemon->priv->skeleton, "handle-get-display-device",
G_CALLBACK (up_daemon_get_display_device), daemon);
}
static const GDBusErrorEntry up_daemon_error_entries[] = {
{ UP_DAEMON_ERROR_GENERAL, UP_INTERFACE_PREFIX "GeneralError" },
{ UP_DAEMON_ERROR_NOT_SUPPORTED, UP_INTERFACE_PREFIX "NotSupported" },
{ UP_DAEMON_ERROR_NO_SUCH_DEVICE, UP_INTERFACE_PREFIX "NoSuchDevice" },
};
/**
* up_daemon_error_quark:
**/
GQuark
up_daemon_error_quark (void)
{
static GQuark ret = 0;
if (ret == 0)
ret = g_quark_from_static_string ("up_daemon_error");
return ret;
}
static volatile gsize quark_volatile = 0;
#define ENUM_ENTRY(NAME, DESC) { NAME, "" #NAME "", DESC }
/**
* up_daemon_error_get_type:
**/
GType
up_daemon_error_get_type (void)
{
static GType etype = 0;
if (etype == 0) {
static const GEnumValue values[] = {
ENUM_ENTRY (UP_DAEMON_ERROR_GENERAL, "GeneralError"),
ENUM_ENTRY (UP_DAEMON_ERROR_NOT_SUPPORTED, "NotSupported"),
ENUM_ENTRY (UP_DAEMON_ERROR_NO_SUCH_DEVICE, "NoSuchDevice"),
{ 0, 0, 0 }
};
g_assert (UP_DAEMON_NUM_ERRORS == G_N_ELEMENTS (values) - 1);
etype = g_enum_register_static ("UpDaemonError", values);
}
return etype;
}
/**
* up_daemon_get_property:
**/
static void
up_daemon_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
UpDaemon *daemon = UP_DAEMON (object);
UpDaemonPrivate *priv = daemon->priv;
switch (prop_id) {
case PROP_DAEMON_VERSION:
g_value_set_string (value, PACKAGE_VERSION);
break;
case PROP_ON_BATTERY:
g_value_set_boolean (value, priv->on_battery);
break;
case PROP_LID_IS_CLOSED:
g_value_set_boolean (value, priv->lid_is_closed);
break;
case PROP_LID_IS_PRESENT:
g_value_set_boolean (value, priv->lid_is_present);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
g_dbus_error_register_error_domain ("up_daemon_error",
&quark_volatile,
up_daemon_error_entries,
G_N_ELEMENTS (up_daemon_error_entries));
return quark_volatile;
}
/**
@ -1248,61 +1054,8 @@ up_daemon_class_init (UpDaemonClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = up_daemon_finalize;
object_class->get_property = up_daemon_get_property;
g_type_class_add_private (klass, sizeof (UpDaemonPrivate));
signals[SIGNAL_DEVICE_ADDED] =
g_signal_new ("device-added",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
0, NULL, NULL,
g_cclosure_marshal_generic,
G_TYPE_NONE, 1, DBUS_TYPE_G_OBJECT_PATH);
signals[SIGNAL_DEVICE_REMOVED] =
g_signal_new ("device-removed",
G_OBJECT_CLASS_TYPE (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
0, NULL, NULL,
g_cclosure_marshal_generic,
G_TYPE_NONE, 1, DBUS_TYPE_G_OBJECT_PATH);
g_object_class_install_property (object_class,
PROP_DAEMON_VERSION,
g_param_spec_string ("daemon-version",
"Daemon Version",
"The version of the running daemon",
NULL,
G_PARAM_READABLE));
g_object_class_install_property (object_class,
PROP_LID_IS_PRESENT,
g_param_spec_boolean ("lid-is-present",
"Is a laptop",
"If this computer is probably a laptop",
FALSE,
G_PARAM_READABLE));
g_object_class_install_property (object_class,
PROP_ON_BATTERY,
g_param_spec_boolean ("on-battery",
"On Battery",
"Whether the system is running on battery",
FALSE,
G_PARAM_READABLE));
g_object_class_install_property (object_class,
PROP_LID_IS_CLOSED,
g_param_spec_boolean ("lid-is-closed",
"Laptop lid is closed",
"If the laptop lid is closed",
FALSE,
G_PARAM_READABLE));
dbus_g_object_type_install_info (UP_TYPE_DAEMON, &dbus_glib_up_daemon_object_info);
dbus_g_error_domain_register (UP_DAEMON_ERROR, NULL, UP_DAEMON_TYPE_ERROR);
}
/**
@ -1316,17 +1069,13 @@ up_daemon_finalize (GObject *object)
if (priv->action_timeout_id != 0)
g_source_remove (priv->action_timeout_id);
if (priv->props_idle_id != 0)
g_source_remove (priv->props_idle_id);
g_clear_pointer (&priv->poll_timeouts, g_hash_table_destroy);
g_clear_pointer (&priv->idle_signals, g_hash_table_destroy);
g_clear_pointer (&daemon->priv->changed_props, g_hash_table_unref);
if (priv->proxy != NULL)
g_object_unref (priv->proxy);
if (priv->connection != NULL)
dbus_g_connection_unref (priv->connection);
g_clear_object (&priv->connection);
g_object_unref (priv->skeleton);
g_object_unref (priv->power_devices);
g_object_unref (priv->display_device);
g_object_unref (priv->config);
@ -1344,3 +1093,8 @@ up_daemon_new (void)
return UP_DAEMON (g_object_new (UP_TYPE_DAEMON, NULL));
}
GDBusConnection *
up_daemon_get_dbus_connection (UpDaemon *daemon)
{
return g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (daemon->priv->skeleton));
}

17
src/up-daemon.h
View file

@ -22,7 +22,6 @@
#define __UP_DAEMON_H__
#include <glib-object.h>
#include <dbus/dbus-glib.h>
#include "up-types.h"
#include "up-device-list.h"
@ -59,9 +58,6 @@ typedef enum
#define UP_DAEMON_ERROR up_daemon_error_quark ()
GType up_daemon_error_get_type (void);
#define UP_DAEMON_TYPE_ERROR (up_daemon_error_get_type ())
GQuark up_daemon_error_quark (void);
GType up_daemon_get_type (void);
UpDaemon *up_daemon_new (void);
@ -73,6 +69,7 @@ guint up_daemon_get_number_devices_of_type (UpDaemon *daemon,
UpDeviceList *up_daemon_get_device_list (UpDaemon *daemon);
gboolean up_daemon_startup (UpDaemon *daemon);
void up_daemon_shutdown (UpDaemon *daemon);
GDBusConnection *up_daemon_get_dbus_connection (UpDaemon *daemon);
void up_daemon_set_lid_is_closed (UpDaemon *daemon,
gboolean lid_is_closed);
void up_daemon_set_lid_is_present (UpDaemon *daemon,
@ -87,23 +84,11 @@ UpDeviceLevel up_daemon_compute_warning_level(UpDaemon *daemon,
gboolean power_supply,
gdouble percentage,
gint64 time_to_empty);
void up_daemon_emit_properties_changed (DBusGConnection *gconnection,
const gchar *object_path,
const gchar *interface,
GHashTable *props);
void up_daemon_start_poll (GObject *object,
GSourceFunc callback);
void up_daemon_stop_poll (GObject *object);
/* exported */
gboolean up_daemon_enumerate_devices (UpDaemon *daemon,
DBusGMethodInvocation *context);
gboolean up_daemon_get_display_device (UpDaemon *daemon,
DBusGMethodInvocation *context);
gboolean up_daemon_get_critical_action (UpDaemon *daemon,
DBusGMethodInvocation *context);
G_END_DECLS
#endif /* __UP_DAEMON_H__ */