fdo-mirrors/upower
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/upower/upower.git synced 2026-01-03 18:20:09 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

abstract out the meta-device into a seporate struct so we can copy it, check for changes and print it

Browse source
This commit is contained in:
Richard Hughes 2008-08-01 16:37:11 +01:00
parent 8d4f138537
commit 1113df1f43
5 changed files with 542 additions and 207 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/Makefile.am
View file

@ -43,6 +43,7 @@ devkit_power_daemon_SOURCES = \
dkp-source.h dkp-source.c \
dkp-enum.h dkp-enum.c \
dkp-debug.h dkp-debug.c \
dkp-object.h dkp-object.c \
sysfs-utils.h sysfs-utils.c \
main.c \
$(BUILT_SOURCES)

335
src/dkp-object.c Normal file
View file

@ -0,0 +1,335 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
*
* Copyright (C) 2008 Richard Hughes <richard@hughsie.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#include <glib.h>
#include <glib-object.h>
#include <string.h>
#include "dkp-debug.h"
#include "dkp-enum.h"
#include "dkp-object.h"
/**
* dkp_object_clear_internal:
**/
static void
dkp_object_clear_internal (DkpObject *obj)
{
obj->type = DKP_SOURCE_TYPE_UNKNOWN;
obj->update_time = 0;
obj->battery_energy = -1;
obj->battery_energy_full = -1;
obj->battery_energy_full_design = -1;
obj->battery_energy_rate = -1;
obj->battery_percentage = -1;
obj->battery_capacity = -1;
obj->battery_time_to_empty = -1;
obj->battery_time_to_full = -1;
obj->battery_state = DKP_SOURCE_STATE_UNKNOWN;
obj->battery_technology = DKP_SOURCE_TECHNOLGY_UNKNOWN;
obj->vendor = NULL;
obj->model = NULL;
obj->serial = NULL;
obj->native_path = NULL;
obj->line_power_online = FALSE;
obj->battery_is_present = FALSE;
obj->power_supply = FALSE;
obj->battery_is_rechargeable = FALSE;
}
/**
* dkp_object_collect_props:
**/
static void
dkp_object_collect_props (const char *key, const GValue *value, DkpObject *obj)
{
gboolean handled = TRUE;
if (strcmp (key, "native-path") == 0)
obj->native_path = g_strdup (g_value_get_string (value));
else if (strcmp (key, "vendor") == 0)
obj->vendor = g_strdup (g_value_get_string (value));
else if (strcmp (key, "model") == 0)
obj->model = g_strdup (g_value_get_string (value));
else if (strcmp (key, "serial") == 0)
obj->serial = g_strdup (g_value_get_string (value));
else if (strcmp (key, "update-time") == 0)
obj->update_time = g_value_get_uint64 (value);
else if (strcmp (key, "type") == 0)
obj->type = dkp_source_type_from_text (g_value_get_string (value));
else if (strcmp (key, "line-power-online") == 0)
obj->line_power_online = g_value_get_boolean (value);
else if (strcmp (key, "battery-energy") == 0)
obj->battery_energy = g_value_get_double (value);
else if (strcmp (key, "battery-energy-empty") == 0)
obj->battery_energy_empty = g_value_get_double (value);
else if (strcmp (key, "battery-energy-full") == 0)
obj->battery_energy_full = g_value_get_double (value);
else if (strcmp (key, "battery-energy-full-design") == 0)
obj->battery_energy_full_design = g_value_get_double (value);
else if (strcmp (key, "battery-energy-rate") == 0)
obj->battery_energy_rate = g_value_get_double (value);
else if (strcmp (key, "battery-time-to-full") == 0)
obj->battery_time_to_full = g_value_get_int64 (value);
else if (strcmp (key, "battery-time-to-empty") == 0)
obj->battery_time_to_empty = g_value_get_int64 (value);
else if (strcmp (key, "battery-percentage") == 0)
obj->battery_percentage = g_value_get_double (value);
else if (strcmp (key, "battery-technology") == 0)
obj->battery_technology = dkp_source_technology_from_text (g_value_get_string (value));
else if (strcmp (key, "battery-is-present") == 0)
obj->battery_is_present = g_value_get_boolean (value);
else if (strcmp (key, "battery-is-rechargeable") == 0)
obj->battery_is_rechargeable = g_value_get_boolean (value);
else if (strcmp (key, "power-supply") == 0)
obj->power_supply = g_value_get_boolean (value);
else if (strcmp (key, "battery-capacity") == 0)
obj->battery_capacity = g_value_get_double (value);
else if (strcmp (key, "battery-state") == 0)
obj->battery_state = dkp_source_state_from_text (g_value_get_string (value));
else
handled = FALSE;
if (!handled)
dkp_warning ("unhandled property '%s'", key);
}
/**
* dkp_object_set_from_map:
**/
gboolean
dkp_object_set_from_map (DkpObject *obj, GHashTable *hash_table)
{
g_hash_table_foreach (hash_table, (GHFunc) dkp_object_collect_props, obj);
return TRUE;
}
/**
* dkp_object_copy:
**/
DkpObject *
dkp_object_copy (const DkpObject *cobj)
{
DkpObject *obj;
obj = g_new0 (DkpObject, 1);
obj->type = cobj->type;
obj->update_time = cobj->update_time;
obj->battery_energy = cobj->battery_energy;
obj->battery_energy_full = cobj->battery_energy_full;
obj->battery_energy_full_design = cobj->battery_energy_full_design;
obj->battery_energy_rate = cobj->battery_energy_rate;
obj->battery_percentage = cobj->battery_percentage;
obj->battery_capacity = cobj->battery_capacity;
obj->battery_time_to_empty = cobj->battery_time_to_empty;
obj->battery_time_to_full = cobj->battery_time_to_full;
obj->battery_state = cobj->battery_state;
obj->battery_technology = cobj->battery_technology;
obj->vendor = g_strdup (cobj->vendor);
obj->model = g_strdup (cobj->model);
obj->serial = g_strdup (cobj->serial);
obj->native_path = g_strdup (cobj->native_path);
obj->line_power_online = cobj->line_power_online;
obj->battery_is_present = cobj->battery_is_present;
obj->power_supply = cobj->power_supply;
obj->battery_is_rechargeable = cobj->battery_is_rechargeable;
return obj;
}
/**
* dkp_object_equal:
**/
gboolean
dkp_object_equal (const DkpObject *obj1, const DkpObject *obj2)
{
if (obj1->type == obj2->type &&
obj1->update_time == obj2->update_time &&
obj1->battery_energy == obj2->battery_energy &&
obj1->battery_energy_full == obj2->battery_energy_full &&
obj1->battery_energy_full_design == obj2->battery_energy_full_design &&
obj1->battery_energy_rate == obj2->battery_energy_rate &&
obj1->battery_percentage == obj2->battery_percentage &&
obj1->battery_capacity == obj2->battery_capacity &&
obj1->battery_time_to_empty == obj2->battery_time_to_empty &&
obj1->battery_time_to_full == obj2->battery_time_to_full &&
obj1->battery_state == obj2->battery_state &&
obj1->battery_technology == obj2->battery_technology &&
strcmp (obj1->vendor, obj2->vendor) == 0 &&
strcmp (obj1->model, obj2->model) == 0 &&
strcmp (obj1->serial, obj2->serial) == 0 &&
strcmp (obj1->native_path, obj2->native_path) == 0 &&
obj1->line_power_online == obj2->line_power_online &&
obj1->battery_is_present == obj2->battery_is_present &&
obj1->power_supply == obj2->power_supply &&
obj1->battery_is_rechargeable == obj2->battery_is_rechargeable)
return TRUE;
return FALSE;
}
/**
* dkp_object_print:
**/
gboolean
dkp_object_print (const DkpObject *obj)
{
gboolean ret = TRUE;
struct tm *time_tm;
time_t t;
gchar time_buf[256];
/* get a human readable time */
t = (time_t) obj->update_time;
time_tm = localtime (&t);
strftime (time_buf, sizeof time_buf, "%c", time_tm);
g_print (" native-path: %s\n", obj->native_path);
g_print (" vendor: %s\n", obj->vendor);
g_print (" model: %s\n", obj->model);
g_print (" serial: %s\n", obj->serial);
g_print (" power supply: %s\n", obj->power_supply ? "yes" : "no");
g_print (" updated: %s (%d seconds ago)\n", time_buf, (int) (time (NULL) - obj->update_time));
if (obj->type == DKP_SOURCE_TYPE_BATTERY) {
g_print (" battery\n");
g_print (" present: %s\n", obj->battery_is_present ? "yes" : "no");
g_print (" rechargeable: %s\n", obj->battery_is_rechargeable ? "yes" : "no");
g_print (" state: %s\n", dkp_source_state_to_text (obj->battery_state));
g_print (" energy: %g Wh\n", obj->battery_energy);
g_print (" energy-empty: %g Wh\n", obj->battery_energy_empty);
g_print (" energy-full: %g Wh\n", obj->battery_energy_full);
g_print (" energy-full-design: %g Wh\n", obj->battery_energy_full_design);
g_print (" energy-rate: %g W\n", obj->battery_energy_rate);
g_print (" time to full: ");
if (obj->battery_time_to_full >= 0)
g_print ("%d seconds\n", (int) obj->battery_time_to_full);
else
g_print ("unknown\n");
g_print (" time to empty: ");
if (obj->battery_time_to_empty >= 0)
g_print ("%d seconds\n", (int) obj->battery_time_to_empty);
else
g_print ("unknown\n");
g_print (" percentage: %g%%\n", obj->battery_percentage);
g_print (" capacity: %g%%\n", obj->battery_capacity);
g_print (" technology: %s\n", dkp_source_technology_to_text (obj->battery_technology));
} else if (obj->type == DKP_SOURCE_TYPE_LINE_POWER) {
g_print (" line-power\n");
g_print (" online: %s\n", obj->line_power_online ? "yes" : "no");
} else {
g_print (" unknown power source type '%s'\n", dkp_source_type_to_text (obj->type));
ret = FALSE;
}
return ret;
}
/**
* dkp_object_new:
**/
DkpObject *
dkp_object_new (void)
{
DkpObject *obj;
obj = g_new0 (DkpObject, 1);
dkp_object_clear_internal (obj);
return obj;
}
/**
* dkp_object_clear:
**/
gboolean
dkp_object_clear (DkpObject *obj)
{
if (obj == NULL)
return FALSE;
dkp_object_free (obj);
dkp_object_clear_internal (obj);
return TRUE;
}
/**
* dkp_object_free:
**/
gboolean
dkp_object_free (DkpObject *obj)
{
if (obj == NULL)
return FALSE;
g_free (obj->vendor);
g_free (obj->model);
g_free (obj->serial);
g_free (obj->native_path);
g_free (obj);
return TRUE;
}
/**
* dkp_object_get_id:
**/
gchar *
dkp_object_get_id (DkpObject *obj)
{
GString *string;
gchar *id = NULL;
/* only valid for devices supplying the system */
if (!obj->power_supply)
return id;
/* only valid for batteries */
if (obj->type != DKP_SOURCE_TYPE_BATTERY)
return id;
/* we don't have an ID if we are not present */
if (!obj->battery_is_present)
return id;
string = g_string_new ("");
/* in an ideal world, model-capacity-serial */
if (obj->model != NULL && strlen (obj->model) > 2) {
g_string_append (string, obj->model);
g_string_append_c (string, '-');
}
if (obj->battery_energy_full_design > 0) {
g_string_append_printf (string, "%i", (guint) obj->battery_energy_full_design);
g_string_append_c (string, '-');
}
if (obj->serial != NULL && strlen (obj->serial) > 2) {
g_string_append (string, obj->serial);
g_string_append_c (string, '-');
}
/* make sure we are sane */
if (string->len == 0) {
/* just use something generic */
g_string_append (string, "generic_id");
} else {
/* remove trailing '-' */
g_string_set_size (string, string->len - 1);
}
/* the id may have invalid chars that need to be replaced */
id = g_string_free (string, FALSE);
g_strdelimit (id, "\\\t\"' /", '_');
return id;
}

67
src/dkp-object.h Normal file
View file

@ -0,0 +1,67 @@
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
*
* Copyright (C) 2008 Richard Hughes <richard@hughsie.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#ifndef __DKP_OBJECT_H__
#define __DKP_OBJECT_H__
#include <glib.h>
#include "dkp-enum.h"
G_BEGIN_DECLS
typedef struct {
guint64 update_time;
gchar *vendor;
gchar *model;
gchar *serial;
gchar *native_path;
gboolean power_supply;
gboolean line_power_online;
gboolean battery_is_present;
gboolean battery_is_rechargeable;
DkpSourceType type;
DkpSourceState battery_state;
DkpSourceTechnology battery_technology;
gdouble battery_capacity;
gdouble battery_energy;
gdouble battery_energy_empty;
gdouble battery_energy_full;
gdouble battery_energy_full_design;
gdouble battery_energy_rate;
gint64 battery_time_to_empty;
gint64 battery_time_to_full;
gdouble battery_percentage;
} DkpObject;
DkpObject *dkp_object_new (void);
gboolean dkp_object_clear (DkpObject *obj);
gboolean dkp_object_free (DkpObject *obj);
gchar *dkp_object_get_id (DkpObject *obj);
DkpObject *dkp_object_copy (const DkpObject *cobj);
gboolean dkp_object_print (const DkpObject *obj);
gboolean dkp_object_equal (const DkpObject *obj1,
const DkpObject *obj2);
gboolean dkp_object_set_from_map (DkpObject *obj,
GHashTable *hash_table);
G_END_DECLS
#endif /* __DKP_OBJECT_H__ */

344
src/dkp-source.c
View file

@ -38,6 +38,7 @@
#include "sysfs-utils.h"
#include "dkp-debug.h"
#include "dkp-enum.h"
#include "dkp-object.h"
#include "dkp-source.h"
#include "dkp-marshal.h"
@ -52,36 +53,10 @@ struct DkpSourcePrivate
DBusGProxy *system_bus_proxy;
DkpDaemon *daemon;
DevkitDevice *d;
gchar *object_path;
gchar *native_path;
guint poll_timer_id;
gchar *vendor;
gchar *model;
gchar *serial;
GTimeVal update_time;
DkpSourceType type;
DkpObject *obj;
gboolean has_coldplug_values;
gboolean power_supply;
gboolean line_power_online;
gboolean battery_is_present;
gboolean battery_is_rechargeable;
DkpSourceState battery_state;
DkpSourceTechnology battery_technology;
gdouble battery_capacity;
gdouble battery_energy;
gdouble battery_energy_empty;
gdouble battery_energy_full;
gdouble battery_energy_full_design;
gdouble battery_energy_rate;
gint64 battery_time_to_empty;
gint64 battery_time_to_full;
gdouble battery_percentage;
gdouble battery_energy_old;
GTimeVal battery_energy_old_timespec;
};
@ -140,74 +115,71 @@ static void
dkp_source_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
DkpSource *source = DKP_SOURCE (object);
DkpObject *obj = source->priv->obj;
switch (prop_id) {
case PROP_NATIVE_PATH:
g_value_set_string (value, source->priv->native_path);
g_value_set_string (value, obj->native_path);
break;
case PROP_VENDOR:
g_value_set_string (value, source->priv->vendor);
g_value_set_string (value, obj->vendor);
break;
case PROP_MODEL:
g_value_set_string (value, source->priv->model);
g_value_set_string (value, obj->model);
break;
case PROP_SERIAL:
g_value_set_string (value, source->priv->serial);
g_value_set_string (value, obj->serial);
break;
case PROP_UPDATE_TIME:
g_value_set_uint64 (value, source->priv->update_time.tv_sec);
g_value_set_uint64 (value, obj->update_time);
break;
case PROP_TYPE:
g_value_set_string (value, dkp_source_type_to_text (source->priv->type));
g_value_set_string (value, dkp_source_type_to_text (obj->type));
break;
case PROP_POWER_SUPPLY:
g_value_set_boolean (value, source->priv->power_supply);
g_value_set_boolean (value, obj->power_supply);
break;
case PROP_LINE_POWER_ONLINE:
g_value_set_boolean (value, source->priv->line_power_online);
g_value_set_boolean (value, obj->line_power_online);
break;
case PROP_BATTERY_IS_PRESENT:
g_value_set_boolean (value, source->priv->battery_is_present);
g_value_set_boolean (value, obj->battery_is_present);
break;
case PROP_BATTERY_IS_RECHARGEABLE:
g_value_set_boolean (value, source->priv->battery_is_rechargeable);
g_value_set_boolean (value, obj->battery_is_rechargeable);
break;
case PROP_BATTERY_STATE:
g_value_set_string (value, dkp_source_state_to_text (source->priv->battery_state));
g_value_set_string (value, dkp_source_state_to_text (obj->battery_state));
break;
case PROP_BATTERY_CAPACITY:
g_value_set_double (value, source->priv->battery_capacity);
g_value_set_double (value, obj->battery_capacity);
break;
case PROP_BATTERY_ENERGY:
g_value_set_double (value, source->priv->battery_energy);
g_value_set_double (value, obj->battery_energy);
break;
case PROP_BATTERY_ENERGY_EMPTY:
g_value_set_double (value, source->priv->battery_energy_empty);
g_value_set_double (value, obj->battery_energy_empty);
break;
case PROP_BATTERY_ENERGY_FULL:
g_value_set_double (value, source->priv->battery_energy_full);
g_value_set_double (value, obj->battery_energy_full);
break;
case PROP_BATTERY_ENERGY_FULL_DESIGN:
g_value_set_double (value, source->priv->battery_energy_full_design);
g_value_set_double (value, obj->battery_energy_full_design);
break;
case PROP_BATTERY_ENERGY_RATE:
g_value_set_double (value, source->priv->battery_energy_rate);
g_value_set_double (value, obj->battery_energy_rate);
break;
case PROP_BATTERY_TIME_TO_EMPTY:
g_value_set_int64 (value, source->priv->battery_time_to_empty);
g_value_set_int64 (value, obj->battery_time_to_empty);
break;
case PROP_BATTERY_TIME_TO_FULL:
g_value_set_int64 (value, source->priv->battery_time_to_full);
g_value_set_int64 (value, obj->battery_time_to_full);
break;
case PROP_BATTERY_PERCENTAGE:
g_value_set_double (value, source->priv->battery_percentage);
g_value_set_double (value, obj->battery_percentage);
break;
case PROP_BATTERY_TECHNOLOGY:
g_value_set_string (value, dkp_source_technology_to_text (source->priv->battery_technology));
g_value_set_string (value, dkp_source_technology_to_text (obj->battery_technology));
break;
default:
@ -247,7 +219,6 @@ dkp_source_class_init (DkpSourceClass *klass)
object_class,
PROP_NATIVE_PATH,
g_param_spec_string ("native-path", NULL, NULL, NULL, G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_VENDOR,
@ -356,12 +327,7 @@ dkp_source_finalize (GObject *object)
g_object_unref (source->priv->d);
g_object_unref (source->priv->daemon);
g_free (source->priv->native_path);
g_free (source->priv->vendor);
g_free (source->priv->model);
g_free (source->priv->serial);
dkp_object_free (source->priv->obj);
if (source->priv->poll_timer_id > 0)
g_source_remove (source->priv->poll_timer_id);
@ -427,7 +393,7 @@ dkp_source_register_power_source (DkpSource *source)
}
connection = dbus_g_connection_get_connection (source->priv->system_bus_connection);
source->priv->object_path = dkp_source_compute_object_path (source->priv->native_path);
source->priv->object_path = dkp_source_compute_object_path (source->priv->obj->native_path);
dbus_g_connection_register_g_object (source->priv->system_bus_connection,
source->priv->object_path, G_OBJECT (source));
@ -456,13 +422,14 @@ dkp_source_new (DkpDaemon *daemon, DevkitDevice *d)
source = DKP_SOURCE (g_object_new (DKP_SOURCE_TYPE_SOURCE, NULL));
source->priv->d = g_object_ref (d);
source->priv->daemon = g_object_ref (daemon);
source->priv->native_path = g_strdup (native_path);
source->priv->obj = dkp_object_new ();
source->priv->obj->native_path = g_strdup (native_path);
if (sysfs_file_exists (native_path, "online")) {
source->priv->type = DKP_SOURCE_TYPE_LINE_POWER;
source->priv->obj->type = DKP_SOURCE_TYPE_LINE_POWER;
} else {
/* this is correct, UPS and CSR are not in the kernel */
source->priv->type = DKP_SOURCE_TYPE_BATTERY;
source->priv->obj->type = DKP_SOURCE_TYPE_BATTERY;
}
if (!dkp_source_update (source)) {
@ -487,11 +454,9 @@ out:
static void
dkp_source_emit_changed (DkpSource *source)
{
dkp_debug ("emitting changed on %s", source->priv->native_path);
g_signal_emit_by_name (source->priv->daemon,
"device-changed",
source->priv->object_path,
NULL);
dkp_debug ("emitting changed on %s", source->priv->obj->native_path);
g_signal_emit_by_name (source->priv->daemon, "device-changed",
source->priv->object_path, NULL);
g_signal_emit (source, signals[CHANGED_SIGNAL], 0);
}
@ -544,7 +509,8 @@ dkp_source_get_object_path (DkpDevice *device)
static gboolean
dkp_source_update_line_power (DkpSource *source)
{
source->priv->line_power_online = sysfs_get_int (source->priv->native_path, "online");
DkpObject *obj = source->priv->obj;
obj->line_power_online = sysfs_get_int (obj->native_path, "online");
return TRUE;
}
@ -554,26 +520,10 @@ dkp_source_update_line_power (DkpSource *source)
static void
dkp_source_reset_values (DkpSource *source)
{
source->priv->battery_energy = -1;
source->priv->battery_energy_old = -1;
source->priv->battery_energy_full = -1;
source->priv->battery_energy_full_design = -1;
source->priv->battery_energy_rate = -1;
source->priv->battery_percentage = -1;
source->priv->battery_capacity = -1;
source->priv->battery_time_to_empty = -1;
source->priv->battery_time_to_full = -1;
source->priv->battery_state = DKP_SOURCE_STATE_UNKNOWN;
source->priv->battery_technology = DKP_SOURCE_TECHNOLGY_UNKNOWN;
source->priv->vendor = NULL;
source->priv->model = NULL;
source->priv->serial = NULL;
source->priv->line_power_online = FALSE;
source->priv->battery_is_present = FALSE;
source->priv->power_supply = FALSE;
source->priv->battery_is_rechargeable = FALSE;
source->priv->has_coldplug_values = FALSE;
source->priv->battery_energy_old = -1;
source->priv->battery_energy_old_timespec.tv_sec = 0;
dkp_object_clear (source->priv->obj);
}
/**
@ -582,51 +532,7 @@ dkp_source_reset_values (DkpSource *source)
gchar *
dkp_source_get_id (DkpSource *source)
{
GString *string;
gchar *id = NULL;
/* only valid for devices supplying the system */
if (!source->priv->power_supply)
return id;
/* only valid for batteries */
if (source->priv->type != DKP_SOURCE_TYPE_BATTERY)
return id;
/* we don't have an ID if we are not present */
if (!source->priv->battery_is_present)
return id;
string = g_string_new ("");
/* in an ideal world, model-capacity-serial */
if (source->priv->model != NULL && strlen (source->priv->model) > 2) {
g_string_append (string, source->priv->model);
g_string_append_c (string, '-');
}
if (source->priv->battery_energy_full_design > 0) {
g_string_append_printf (string, "%i", (guint) source->priv->battery_energy_full_design);
g_string_append_c (string, '-');
}
if (source->priv->serial != NULL && strlen (source->priv->serial) > 2) {
g_string_append (string, source->priv->serial);
g_string_append_c (string, '-');
}
/* make sure we are sane */
if (string->len == 0) {
/* just use something generic */
g_string_append (string, "generic_id");
} else {
/* remove trailing '-' */
g_string_set_size (string, string->len - 1);
}
/* the id may have invalid chars that need to be replaced */
id = g_string_free (string, FALSE);
g_strdelimit (id, "\\\t\"' /", '_');
return id;
return dkp_object_get_id (source->priv->obj);
}
/**
@ -638,14 +544,15 @@ dkp_source_calculate_battery_rate (DkpSource *source)
guint time;
gdouble energy;
GTimeVal now;
DkpObject *obj = source->priv->obj;
if (source->priv->battery_energy < 0)
if (obj->battery_energy < 0)
return;
if (source->priv->battery_energy_old < 0)
return;
if (source->priv->battery_energy_old == source->priv->battery_energy)
if (source->priv->battery_energy_old == obj->battery_energy)
return;
/* get the time difference */
@ -656,33 +563,40 @@ dkp_source_calculate_battery_rate (DkpSource *source)
return;
/* get the difference in charge */
energy = source->priv->battery_energy_old - source->priv->battery_energy;
energy = source->priv->battery_energy_old - obj->battery_energy;
if (energy < 0.1)
return;
/* probably okay */
source->priv->battery_energy_rate = energy * 3600 / time;
obj->battery_energy_rate = energy * 3600 / time;
}
/**
* dkp_source_update_battery:
*
* Return value: TRUE if we changed
**/
static gboolean
dkp_source_update_battery (DkpSource *source)
{
gchar *status;
gchar *status = NULL;
gboolean ret;
gboolean just_added = FALSE;
gboolean is_charging;
gboolean is_discharging;
DkpSourceState battery_state;
DkpObject *obj = source->priv->obj;
DkpObject *obj_old;
/* are we present? */
source->priv->battery_is_present = sysfs_get_bool (source->priv->native_path, "present");
if (!source->priv->battery_is_present) {
g_free (source->priv->vendor);
g_free (source->priv->model);
g_free (source->priv->serial);
/* make a copy so we can see if anything changed */
obj_old = dkp_object_copy (obj);
/* have we just been removed? */
obj->battery_is_present = sysfs_get_bool (obj->native_path, "present");
if (!obj->battery_is_present) {
dkp_source_reset_values (source);
return TRUE;
obj->type = DKP_SOURCE_TYPE_BATTERY;
goto out;
}
/* initial values */
@ -690,43 +604,43 @@ dkp_source_update_battery (DkpSource *source)
gchar *technology_native;
/* when we add via sysfs power_supply class then we know this is true */
source->priv->power_supply = TRUE;
obj->power_supply = TRUE;
/* the ACPI spec is bad at defining battery type constants */
technology_native = g_strstrip (sysfs_get_string (source->priv->native_path, "technology"));
source->priv->battery_technology = dkp_acpi_to_source_technology (technology_native);
technology_native = g_strstrip (sysfs_get_string (obj->native_path, "technology"));
obj->battery_technology = dkp_acpi_to_source_technology (technology_native);
g_free (technology_native);
source->priv->vendor = g_strstrip (sysfs_get_string (source->priv->native_path, "manufacturer"));
source->priv->model = g_strstrip (sysfs_get_string (source->priv->native_path, "model_name"));
source->priv->serial = g_strstrip (sysfs_get_string (source->priv->native_path, "serial_number"));
obj->vendor = g_strstrip (sysfs_get_string (obj->native_path, "manufacturer"));
obj->model = g_strstrip (sysfs_get_string (obj->native_path, "model_name"));
obj->serial = g_strstrip (sysfs_get_string (obj->native_path, "serial_number"));
/* assume true for laptops */
source->priv->battery_is_rechargeable = TRUE;
obj->battery_is_rechargeable = TRUE;
/* these don't change at runtime */
source->priv->battery_energy_full =
sysfs_get_double (source->priv->native_path, "energy_full") / 1000000.0;
source->priv->battery_energy_full_design =
sysfs_get_double (source->priv->native_path, "energy_full_design") / 1000000.0;
obj->battery_energy_full =
sysfs_get_double (obj->native_path, "energy_full") / 1000000.0;
obj->battery_energy_full_design =
sysfs_get_double (obj->native_path, "energy_full_design") / 1000000.0;
/* the last full cannot be bigger than the design */
if (source->priv->battery_energy_full > source->priv->battery_energy_full_design)
source->priv->battery_energy_full = source->priv->battery_energy_full_design;
if (obj->battery_energy_full > obj->battery_energy_full_design)
obj->battery_energy_full = obj->battery_energy_full_design;
/* calculate how broken our battery is */
source->priv->battery_capacity = source->priv->battery_energy_full_design /
source->priv->battery_energy_full * 100.0f;
if (source->priv->battery_capacity < 0)
source->priv->battery_capacity = 0;
if (source->priv->battery_capacity > 100.0)
source->priv->battery_capacity = 100.0;
obj->battery_capacity = obj->battery_energy_full_design / obj->battery_energy_full * 100.0f;
if (obj->battery_capacity < 0)
obj->battery_capacity = 0;
if (obj->battery_capacity > 100.0)
obj->battery_capacity = 100.0;
/* we only coldplug once, as these values will never change */
source->priv->has_coldplug_values = TRUE;
just_added = TRUE;
}
status = g_strstrip (sysfs_get_string (source->priv->native_path, "status"));
status = g_strstrip (sysfs_get_string (obj->native_path, "status"));
is_charging = strcasecmp (status, "charging") == 0;
is_discharging = strcasecmp (status, "discharging") == 0;
@ -735,87 +649,93 @@ dkp_source_update_battery (DkpSource *source)
is_discharging = FALSE;
/* get the currect charge */
source->priv->battery_energy =
sysfs_get_double (source->priv->native_path, "energy_avg") / 1000000.0;
if (source->priv->battery_energy == 0)
source->priv->battery_energy =
sysfs_get_double (source->priv->native_path, "energy_now") / 1000000.0;
obj->battery_energy =
sysfs_get_double (obj->native_path, "energy_avg") / 1000000.0;
if (obj->battery_energy == 0)
obj->battery_energy =
sysfs_get_double (obj->native_path, "energy_now") / 1000000.0;
/* some batteries don't update last_full attribute */
if (source->priv->battery_energy > source->priv->battery_energy_full)
source->priv->battery_energy_full = source->priv->battery_energy;
if (obj->battery_energy > obj->battery_energy_full)
obj->battery_energy_full = obj->battery_energy;
source->priv->battery_energy_rate =
fabs (sysfs_get_double (source->priv->native_path, "current_now") / 1000000.0);
obj->battery_energy_rate =
fabs (sysfs_get_double (obj->native_path, "current_now") / 1000000.0);
/* ACPI gives out the special 'Ones' value for rate when it's unable
* to calculate the true rate. We should set the rate zero, and wait
* for the BIOS to stabilise. */
if (source->priv->battery_energy_rate == 0xffff)
source->priv->battery_energy_rate = -1;
if (obj->battery_energy_rate == 0xffff)
obj->battery_energy_rate = -1;
/* sanity check to less than 100W */
if (source->priv->battery_energy_rate > 100*1000)
source->priv->battery_energy_rate = -1;
if (obj->battery_energy_rate > 100*1000)
obj->battery_energy_rate = -1;
/* the hardware reporting failed -- try to calculate this */
if (source->priv->battery_energy_rate < 0) {
if (obj->battery_energy_rate < 0) {
dkp_source_calculate_battery_rate (source);
}
/* charging has a negative rate */
if (source->priv->battery_energy_rate > 0 && is_charging)
source->priv->battery_energy_rate *= -1.0;
if (obj->battery_energy_rate > 0 && is_charging)
obj->battery_energy_rate *= -1.0;
/* get a precise percentage */
source->priv->battery_percentage = 100.0 * source->priv->battery_energy / source->priv->battery_energy_full;
if (source->priv->battery_percentage < 0)
source->priv->battery_percentage = 0;
if (source->priv->battery_percentage > 100.0)
source->priv->battery_percentage = 100.0;
obj->battery_percentage = 100.0 * obj->battery_energy / obj->battery_energy_full;
if (obj->battery_percentage < 0)
obj->battery_percentage = 0;
if (obj->battery_percentage > 100.0)
obj->battery_percentage = 100.0;
/* calculate a quick and dirty time remaining value */
source->priv->battery_time_to_empty = -1;
source->priv->battery_time_to_full = -1;
if (source->priv->battery_energy_rate > 0) {
obj->battery_time_to_empty = -1;
obj->battery_time_to_full = -1;
if (obj->battery_energy_rate > 0) {
if (is_discharging) {
source->priv->battery_time_to_empty = 3600 * (source->priv->battery_energy /
source->priv->battery_energy_rate);
obj->battery_time_to_empty = 3600 * (obj->battery_energy / obj->battery_energy_rate);
} else if (is_charging) {
source->priv->battery_time_to_full = 3600 *
((source->priv->battery_energy_full - source->priv->battery_energy) /
source->priv->battery_energy_rate);
obj->battery_time_to_full = 3600 * ((obj->battery_energy_full - obj->battery_energy) / obj->battery_energy_rate);
}
}
/* check the remaining time is under a set limit, to deal with broken
primary batteries rate */
if (source->priv->battery_time_to_empty > (100 * 60 * 60))
source->priv->battery_time_to_empty = -1;
if (source->priv->battery_time_to_full > (100 * 60 * 60))
source->priv->battery_time_to_full = -1;
if (obj->battery_time_to_empty > (100 * 60 * 60))
obj->battery_time_to_empty = -1;
if (obj->battery_time_to_full > (100 * 60 * 60))
obj->battery_time_to_full = -1;
/* get the state */
if (is_charging)
battery_state = DKP_SOURCE_STATE_CHARGING;
else if (is_discharging)
battery_state = DKP_SOURCE_STATE_DISCHARGING;
else if (source->priv->battery_percentage > DK_POWER_MIN_CHARGED_PERCENTAGE)
else if (obj->battery_percentage > DK_POWER_MIN_CHARGED_PERCENTAGE)
battery_state = DKP_SOURCE_STATE_FULLY_CHARGED;
else
battery_state = DKP_SOURCE_STATE_EMPTY;
/* set the old status */
source->priv->battery_energy_old = source->priv->battery_energy;
source->priv->battery_energy_old = obj->battery_energy;
g_get_current_time (&source->priv->battery_energy_old_timespec);
/* we changed state */
if (source->priv->battery_state != battery_state) {
if (obj->battery_state != battery_state) {
source->priv->battery_energy_old = -1;
source->priv->battery_state = battery_state;
obj->battery_state = battery_state;
}
out:
/* did anything change? */
ret = !dkp_object_equal (obj, obj_old);
dkp_object_free (obj_old);
/* just for debugging */
if (just_added)
dkp_object_print (obj);
g_free (status);
return TRUE;
return ret;
}
/**
@ -824,29 +744,39 @@ dkp_source_update_battery (DkpSource *source)
static gboolean
dkp_source_poll_battery (DkpSource *source)
{
dkp_debug ("No updates on source %s for 30 seconds; forcing update", source->priv->native_path);
gboolean ret;
DkpObject *obj = source->priv->obj;
dkp_debug ("No updates on source %s for 30 seconds; forcing update", obj->native_path);
source->priv->poll_timer_id = 0;
dkp_source_update (source);
dkp_source_emit_changed (source);
ret = dkp_source_update (source);
if (ret) {
dkp_source_emit_changed (source);
dkp_object_print (source->priv->obj);
}
return FALSE;
}
/**
* dkp_source_update:
*
* Return value: TRUE if we changed
**/
static gboolean
dkp_source_update (DkpSource *source)
{
gboolean ret;
GTimeVal time;
if (source->priv->poll_timer_id > 0) {
g_source_remove (source->priv->poll_timer_id);
source->priv->poll_timer_id = 0;
}
g_get_current_time (&(source->priv->update_time));
g_get_current_time (&time);
source->priv->obj->update_time = time.tv_sec;
switch (source->priv->type) {
switch (source->priv->obj->type) {
case DKP_SOURCE_TYPE_LINE_POWER:
ret = dkp_source_update_line_power (source);
break;

2
tools/Makefile.am
View file

@ -32,6 +32,8 @@ bin_PROGRAMS = devkit-power
devkit_power_SOURCES = \
dkp-tool.c \
../src/dkp-debug.h ../src/dkp-debug.c \
../src/dkp-object.h ../src/dkp-object.c \
../src/dkp-enum.h ../src/dkp-enum.c \
$(BUILT_SOURCES)