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

Merge branch 'master' into temp

Browse source
This commit is contained in:
Richard Hughes 2008-08-26 16:04:36 +01:00
commit 83b4c54818
8 changed files with 282 additions and 282 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

250
libdevkit-power/dkp-object.c
View file

@ -34,24 +34,24 @@ dkp_object_clear_internal (DkpObject *obj)
{
obj->type = DKP_DEVICE_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_DEVICE_STATE_UNKNOWN;
obj->battery_technology = DKP_DEVICE_TECHNOLGY_UNKNOWN;
obj->energy = -1;
obj->energy_full = -1;
obj->energy_full_design = -1;
obj->energy_rate = -1;
obj->percentage = -1;
obj->capacity = -1;
obj->time_to_empty = -1;
obj->time_to_full = -1;
obj->state = DKP_DEVICE_STATE_UNKNOWN;
obj->technology = DKP_DEVICE_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->online = FALSE;
obj->is_present = FALSE;
obj->power_supply = FALSE;
obj->battery_is_rechargeable = FALSE;
obj->is_rechargeable = FALSE;
}
/**
@ -74,36 +74,36 @@ dkp_object_collect_props (const char *key, const GValue *value, DkpObject *obj)
obj->update_time = g_value_get_uint64 (value);
else if (strcmp (key, "type") == 0)
obj->type = dkp_device_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_device_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, "online") == 0)
obj->online = g_value_get_boolean (value);
else if (strcmp (key, "energy") == 0)
obj->energy = g_value_get_double (value);
else if (strcmp (key, "energy-empty") == 0)
obj->energy_empty = g_value_get_double (value);
else if (strcmp (key, "energy-full") == 0)
obj->energy_full = g_value_get_double (value);
else if (strcmp (key, "energy-full-design") == 0)
obj->energy_full_design = g_value_get_double (value);
else if (strcmp (key, "energy-rate") == 0)
obj->energy_rate = g_value_get_double (value);
else if (strcmp (key, "time-to-full") == 0)
obj->time_to_full = g_value_get_int64 (value);
else if (strcmp (key, "time-to-empty") == 0)
obj->time_to_empty = g_value_get_int64 (value);
else if (strcmp (key, "percentage") == 0)
obj->percentage = g_value_get_double (value);
else if (strcmp (key, "technology") == 0)
obj->technology = dkp_device_technology_from_text (g_value_get_string (value));
else if (strcmp (key, "is-present") == 0)
obj->is_present = g_value_get_boolean (value);
else if (strcmp (key, "is-rechargeable") == 0)
obj->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_device_state_from_text (g_value_get_string (value));
else if (strcmp (key, "capacity") == 0)
obj->capacity = g_value_get_double (value);
else if (strcmp (key, "state") == 0)
obj->state = dkp_device_state_from_text (g_value_get_string (value));
else
handled = FALSE;
@ -132,24 +132,24 @@ dkp_object_copy (const DkpObject *cobj)
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->energy = cobj->energy;
obj->energy_full = cobj->energy_full;
obj->energy_full_design = cobj->energy_full_design;
obj->energy_rate = cobj->energy_rate;
obj->percentage = cobj->percentage;
obj->capacity = cobj->capacity;
obj->time_to_empty = cobj->time_to_empty;
obj->time_to_full = cobj->time_to_full;
obj->state = cobj->state;
obj->technology = cobj->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->online = cobj->online;
obj->is_present = cobj->is_present;
obj->power_supply = cobj->power_supply;
obj->battery_is_rechargeable = cobj->battery_is_rechargeable;
obj->is_rechargeable = cobj->is_rechargeable;
return obj;
}
@ -182,24 +182,24 @@ 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 &&
obj1->energy == obj2->energy &&
obj1->energy_full == obj2->energy_full &&
obj1->energy_full_design == obj2->energy_full_design &&
obj1->energy_rate == obj2->energy_rate &&
obj1->percentage == obj2->percentage &&
obj1->capacity == obj2->capacity &&
obj1->time_to_empty == obj2->time_to_empty &&
obj1->time_to_full == obj2->time_to_full &&
obj1->state == obj2->state &&
obj1->technology == obj2->technology &&
dkp_strequal (obj1->vendor, obj2->vendor) &&
dkp_strequal (obj1->model, obj2->model) &&
dkp_strequal (obj1->serial, obj2->serial) &&
dkp_strequal (obj1->native_path, obj2->native_path) &&
obj1->line_power_online == obj2->line_power_online &&
obj1->battery_is_present == obj2->battery_is_present &&
obj1->online == obj2->online &&
obj1->is_present == obj2->is_present &&
obj1->power_supply == obj2->power_supply &&
obj1->battery_is_rechargeable == obj2->battery_is_rechargeable)
obj1->is_rechargeable == obj2->is_rechargeable)
return TRUE;
return FALSE;
}
@ -290,33 +290,33 @@ dkp_object_print (const DkpObject *obj)
obj->type == DKP_DEVICE_TYPE_MOUSE ||
obj->type == DKP_DEVICE_TYPE_KEYBOARD ||
obj->type == DKP_DEVICE_TYPE_UPS)
g_print (" present: %s\n", dkp_object_bool_to_text (obj->battery_is_present));
g_print (" present: %s\n", dkp_object_bool_to_text (obj->is_present));
if (obj->type == DKP_DEVICE_TYPE_BATTERY ||
obj->type == DKP_DEVICE_TYPE_MOUSE ||
obj->type == DKP_DEVICE_TYPE_KEYBOARD)
g_print (" rechargeable: %s\n", dkp_object_bool_to_text (obj->battery_is_rechargeable));
g_print (" rechargeable: %s\n", dkp_object_bool_to_text (obj->is_rechargeable));
if (obj->type == DKP_DEVICE_TYPE_BATTERY ||
obj->type == DKP_DEVICE_TYPE_MOUSE ||
obj->type == DKP_DEVICE_TYPE_KEYBOARD)
g_print (" state: %s\n", dkp_device_state_to_text (obj->battery_state));
g_print (" state: %s\n", dkp_device_state_to_text (obj->state));
if (obj->type == DKP_DEVICE_TYPE_BATTERY) {
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: %g Wh\n", obj->energy);
g_print (" energy-empty: %g Wh\n", obj->energy_empty);
g_print (" energy-full: %g Wh\n", obj->energy_full);
g_print (" energy-full-design: %g Wh\n", obj->energy_full_design);
}
if (obj->type == DKP_DEVICE_TYPE_BATTERY ||
obj->type == DKP_DEVICE_TYPE_MONITOR)
g_print (" energy-rate: %g W\n", obj->battery_energy_rate);
g_print (" energy-rate: %g W\n", obj->energy_rate);
if (obj->type == DKP_DEVICE_TYPE_BATTERY ||
obj->type == DKP_DEVICE_TYPE_UPS) {
if (obj->battery_time_to_full >= 0) {
time_str = dkp_object_time_to_text (obj->battery_time_to_full);
if (obj->time_to_full >= 0) {
time_str = dkp_object_time_to_text (obj->time_to_full);
g_print (" time to full: %s\n", time_str);
g_free (time_str);
}
if (obj->battery_time_to_empty >= 0) {
time_str = dkp_object_time_to_text (obj->battery_time_to_empty);
if (obj->time_to_empty >= 0) {
time_str = dkp_object_time_to_text (obj->time_to_empty);
g_print (" time to empty: %s\n", time_str);
g_free (time_str);
}
@ -325,13 +325,13 @@ dkp_object_print (const DkpObject *obj)
obj->type == DKP_DEVICE_TYPE_MOUSE ||
obj->type == DKP_DEVICE_TYPE_KEYBOARD ||
obj->type == DKP_DEVICE_TYPE_UPS)
g_print (" percentage: %g%%\n", obj->battery_percentage);
g_print (" percentage: %g%%\n", obj->percentage);
if (obj->type == DKP_DEVICE_TYPE_BATTERY)
g_print (" capacity: %g%%\n", obj->battery_capacity);
g_print (" capacity: %g%%\n", obj->capacity);
if (obj->type == DKP_DEVICE_TYPE_BATTERY)
g_print (" technology: %s\n", dkp_device_technology_to_text (obj->battery_technology));
g_print (" technology: %s\n", dkp_device_technology_to_text (obj->technology));
if (obj->type == DKP_DEVICE_TYPE_LINE_POWER)
g_print (" online: %s\n", dkp_object_bool_to_text (obj->line_power_online));
g_print (" online: %s\n", dkp_object_bool_to_text (obj->online));
return ret;
}
@ -357,58 +357,58 @@ dkp_object_diff (const DkpObject *old, const DkpObject *obj)
if (obj->type == DKP_DEVICE_TYPE_BATTERY ||
obj->type == DKP_DEVICE_TYPE_MOUSE ||
obj->type == DKP_DEVICE_TYPE_KEYBOARD)
if (old->battery_is_present != obj->battery_is_present)
if (old->is_present != obj->is_present)
g_print (" present: %s -> %s\n",
dkp_object_bool_to_text (old->battery_is_present),
dkp_object_bool_to_text (obj->battery_is_present));
dkp_object_bool_to_text (old->is_present),
dkp_object_bool_to_text (obj->is_present));
if (obj->type == DKP_DEVICE_TYPE_BATTERY)
if (old->battery_is_rechargeable != obj->battery_is_rechargeable)
if (old->is_rechargeable != obj->is_rechargeable)
g_print (" rechargeable: %s -> %s\n",
dkp_object_bool_to_text (old->battery_is_rechargeable),
dkp_object_bool_to_text (obj->battery_is_rechargeable));
dkp_object_bool_to_text (old->is_rechargeable),
dkp_object_bool_to_text (obj->is_rechargeable));
if (obj->type == DKP_DEVICE_TYPE_BATTERY ||
obj->type == DKP_DEVICE_TYPE_MOUSE ||
obj->type == DKP_DEVICE_TYPE_KEYBOARD ||
obj->type == DKP_DEVICE_TYPE_UPS)
if (old->battery_state != obj->battery_state)
if (old->state != obj->state)
g_print (" state: %s -> %s\n",
dkp_device_state_to_text (old->battery_state),
dkp_device_state_to_text (obj->battery_state));
dkp_device_state_to_text (old->state),
dkp_device_state_to_text (obj->state));
if (obj->type == DKP_DEVICE_TYPE_BATTERY) {
if (old->battery_energy != obj->battery_energy)
if (old->energy != obj->energy)
g_print (" energy: %g -> %g Wh\n",
old->battery_energy,
obj->battery_energy);
if (old->battery_energy_empty != obj->battery_energy_empty)
old->energy,
obj->energy);
if (old->energy_empty != obj->energy_empty)
g_print (" energy-empty: %g -> %g Wh\n",
old->battery_energy_empty,
obj->battery_energy_empty);
if (old->battery_energy_full != obj->battery_energy_full)
old->energy_empty,
obj->energy_empty);
if (old->energy_full != obj->energy_full)
g_print (" energy-full: %g -> %g Wh\n",
old->battery_energy_full,
obj->battery_energy_full);
if (old->battery_energy_full_design != obj->battery_energy_full_design)
old->energy_full,
obj->energy_full);
if (old->energy_full_design != obj->energy_full_design)
g_print (" energy-full-design: %g -> %g Wh\n",
old->battery_energy_full_design,
obj->battery_energy_full_design);
old->energy_full_design,
obj->energy_full_design);
}
if (obj->type == DKP_DEVICE_TYPE_BATTERY ||
obj->type == DKP_DEVICE_TYPE_MONITOR)
if (old->battery_energy_rate != obj->battery_energy_rate)
if (old->energy_rate != obj->energy_rate)
g_print (" energy-rate: %g -> %g W\n",
old->battery_energy_rate, obj->battery_energy_rate);
old->energy_rate, obj->energy_rate);
if (obj->type == DKP_DEVICE_TYPE_BATTERY ||
obj->type == DKP_DEVICE_TYPE_UPS) {
if (old->battery_time_to_full != obj->battery_time_to_full) {
time_str_old = dkp_object_time_to_text (old->battery_time_to_full);
time_str = dkp_object_time_to_text (obj->battery_time_to_full);
if (old->time_to_full != obj->time_to_full) {
time_str_old = dkp_object_time_to_text (old->time_to_full);
time_str = dkp_object_time_to_text (obj->time_to_full);
g_print (" time to full: %s -> %s\n", time_str_old, time_str);
g_free (time_str_old);
g_free (time_str);
}
if (old->battery_time_to_empty != obj->battery_time_to_empty) {
time_str_old = dkp_object_time_to_text (old->battery_time_to_empty);
time_str = dkp_object_time_to_text (obj->battery_time_to_empty);
if (old->time_to_empty != obj->time_to_empty) {
time_str_old = dkp_object_time_to_text (old->time_to_empty);
time_str = dkp_object_time_to_text (obj->time_to_empty);
g_print (" time to empty: %s -> %s\n", time_str_old, time_str);
g_free (time_str_old);
g_free (time_str);
@ -418,23 +418,23 @@ dkp_object_diff (const DkpObject *old, const DkpObject *obj)
obj->type == DKP_DEVICE_TYPE_UPS ||
obj->type == DKP_DEVICE_TYPE_MOUSE ||
obj->type == DKP_DEVICE_TYPE_KEYBOARD)
if (old->battery_percentage != obj->battery_percentage)
if (old->percentage != obj->percentage)
g_print (" percentage: %g%% -> %g%%\n",
old->battery_percentage, obj->battery_percentage);
old->percentage, obj->percentage);
if (obj->type == DKP_DEVICE_TYPE_BATTERY)
if (old->battery_capacity != obj->battery_capacity)
if (old->capacity != obj->capacity)
g_print (" capacity: %g%% -> %g%%\n",
old->battery_capacity, obj->battery_capacity);
old->capacity, obj->capacity);
if (obj->type == DKP_DEVICE_TYPE_BATTERY)
if (old->battery_technology != obj->battery_technology)
if (old->technology != obj->technology)
g_print (" technology: %s -> %s\n",
dkp_device_technology_to_text (old->battery_technology),
dkp_device_technology_to_text (obj->battery_technology));
dkp_device_technology_to_text (old->technology),
dkp_device_technology_to_text (obj->technology));
if (obj->type == DKP_DEVICE_TYPE_LINE_POWER)
if (old->line_power_online != obj->line_power_online)
if (old->online != obj->online)
g_print (" online: %s -> %s\n",
dkp_object_bool_to_text (old->line_power_online),
dkp_object_bool_to_text (obj->line_power_online));
dkp_object_bool_to_text (old->online),
dkp_object_bool_to_text (obj->online));
return TRUE;
}
@ -507,7 +507,7 @@ dkp_object_get_id (DkpObject *obj)
return id;
/* we don't have an ID if we are not present */
if (!obj->battery_is_present)
if (!obj->is_present)
return id;
string = g_string_new ("");
@ -517,8 +517,8 @@ dkp_object_get_id (DkpObject *obj)
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);
if (obj->energy_full_design > 0) {
g_string_append_printf (string, "%i", (guint) obj->energy_full_design);
g_string_append_c (string, '-');
}
if (obj->serial != NULL && strlen (obj->serial) > 2) {

28
libdevkit-power/dkp-object.h
View file

@ -33,21 +33,21 @@ typedef struct {
gchar *serial;
gchar *native_path;
gboolean power_supply;
gboolean line_power_online;
gboolean battery_is_present;
gboolean battery_is_rechargeable;
gboolean online;
gboolean is_present;
gboolean is_rechargeable;
DkpDeviceType type;
DkpDeviceState battery_state;
DkpDeviceTechnology battery_technology;
gdouble battery_capacity; /* percent */
gdouble battery_energy; /* Watt Hours */
gdouble battery_energy_empty; /* Watt Hours */
gdouble battery_energy_full; /* Watt Hours */
gdouble battery_energy_full_design; /* Watt Hours */
gdouble battery_energy_rate; /* Watts */
gint64 battery_time_to_empty; /* seconds */
gint64 battery_time_to_full; /* seconds */
gdouble battery_percentage; /* percent */
DkpDeviceState state;
DkpDeviceTechnology technology;
gdouble capacity; /* percent */
gdouble energy; /* Watt Hours */
gdouble energy_empty; /* Watt Hours */
gdouble energy_full; /* Watt Hours */
gdouble energy_full_design; /* Watt Hours */
gdouble energy_rate; /* Watts */
gint64 time_to_empty; /* seconds */
gint64 time_to_full; /* seconds */
gdouble percentage; /* percent */
} DkpObject;
DkpObject *dkp_object_new (void);

10
src/dkp-csr.c
View file

@ -187,9 +187,9 @@ dkp_csr_coldplug (DkpDevice *device)
obj->vendor = g_strdup (devkit_device_get_property (d, "ID_VENDOR"));
obj->model = g_strdup (devkit_device_get_property (d, "ID_PRODUCT"));
obj->power_supply = FALSE;
obj->battery_is_present = TRUE;
obj->battery_is_rechargeable = TRUE;
obj->battery_state = DKP_DEVICE_STATE_DISCHARGING;
obj->is_present = TRUE;
obj->is_rechargeable = TRUE;
obj->state = DKP_DEVICE_STATE_DISCHARGING;
/* coldplug */
ret = dkp_csr_refresh (device);
@ -257,8 +257,8 @@ dkp_csr_refresh (DkpDevice *device)
csr->priv->raw_value = CSR_P5 & 0x07;
dkp_debug ("charge level: %d", csr->priv->raw_value);
if (csr->priv->raw_value != 0) {
obj->battery_percentage = (100.0 / 7.0) * csr->priv->raw_value;
dkp_debug ("percentage=%f", obj->battery_percentage);
obj->percentage = (100.0 / 7.0) * csr->priv->raw_value;
dkp_debug ("percentage=%f", obj->percentage);
}
out:

56
src/dkp-device.c
View file

@ -168,46 +168,46 @@ dkp_device_get_property (GObject *object, guint prop_id, GValue *value, GParamSp
g_value_set_boolean (value, obj->power_supply);
break;
case PROP_LINE_POWER_ONLINE:
g_value_set_boolean (value, obj->line_power_online);
g_value_set_boolean (value, obj->online);
break;
case PROP_BATTERY_IS_PRESENT:
g_value_set_boolean (value, obj->battery_is_present);
g_value_set_boolean (value, obj->is_present);
break;
case PROP_BATTERY_IS_RECHARGEABLE:
g_value_set_boolean (value, obj->battery_is_rechargeable);
g_value_set_boolean (value, obj->is_rechargeable);
break;
case PROP_BATTERY_STATE:
g_value_set_string (value, dkp_device_state_to_text (obj->battery_state));
g_value_set_string (value, dkp_device_state_to_text (obj->state));
break;
case PROP_BATTERY_CAPACITY:
g_value_set_double (value, obj->battery_capacity);
g_value_set_double (value, obj->capacity);
break;
case PROP_BATTERY_ENERGY:
g_value_set_double (value, obj->battery_energy);
g_value_set_double (value, obj->energy);
break;
case PROP_BATTERY_ENERGY_EMPTY:
g_value_set_double (value, obj->battery_energy_empty);
g_value_set_double (value, obj->energy_empty);
break;
case PROP_BATTERY_ENERGY_FULL:
g_value_set_double (value, obj->battery_energy_full);
g_value_set_double (value, obj->energy_full);
break;
case PROP_BATTERY_ENERGY_FULL_DESIGN:
g_value_set_double (value, obj->battery_energy_full_design);
g_value_set_double (value, obj->energy_full_design);
break;
case PROP_BATTERY_ENERGY_RATE:
g_value_set_double (value, obj->battery_energy_rate);
g_value_set_double (value, obj->energy_rate);
break;
case PROP_BATTERY_TIME_TO_EMPTY:
g_value_set_int64 (value, obj->battery_time_to_empty);
g_value_set_int64 (value, obj->time_to_empty);
break;
case PROP_BATTERY_TIME_TO_FULL:
g_value_set_int64 (value, obj->battery_time_to_full);
g_value_set_int64 (value, obj->time_to_full);
break;
case PROP_BATTERY_PERCENTAGE:
g_value_set_double (value, obj->battery_percentage);
g_value_set_double (value, obj->percentage);
break;
case PROP_BATTERY_TECHNOLOGY:
g_value_set_string (value, dkp_device_technology_to_text (obj->battery_technology));
g_value_set_string (value, dkp_device_technology_to_text (obj->technology));
break;
default:
@ -622,59 +622,59 @@ dkp_device_class_init (DkpDeviceClass *klass)
g_object_class_install_property (
object_class,
PROP_LINE_POWER_ONLINE,
g_param_spec_boolean ("line-power-online", NULL, NULL, FALSE, G_PARAM_READABLE));
g_param_spec_boolean ("online", NULL, NULL, FALSE, G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_BATTERY_ENERGY,
g_param_spec_double ("battery-energy", NULL, NULL, 0, G_MAXDOUBLE, 0, G_PARAM_READABLE));
g_param_spec_double ("energy", NULL, NULL, 0, G_MAXDOUBLE, 0, G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_BATTERY_IS_PRESENT,
g_param_spec_boolean ("battery-is-present", NULL, NULL, FALSE, G_PARAM_READABLE));
g_param_spec_boolean ("is-present", NULL, NULL, FALSE, G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_BATTERY_IS_RECHARGEABLE,
g_param_spec_boolean ("battery-is-rechargeable", NULL, NULL, FALSE, G_PARAM_READABLE));
g_param_spec_boolean ("is-rechargeable", NULL, NULL, FALSE, G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_BATTERY_STATE,
g_param_spec_string ("battery-state", NULL, NULL, NULL, G_PARAM_READABLE));
g_param_spec_string ("state", NULL, NULL, NULL, G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_BATTERY_CAPACITY,
g_param_spec_double ("battery-capacity", NULL, NULL, 0, G_MAXDOUBLE, 0, G_PARAM_READABLE));
g_param_spec_double ("capacity", NULL, NULL, 0, G_MAXDOUBLE, 0, G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_BATTERY_ENERGY_EMPTY,
g_param_spec_double ("battery-energy-empty", NULL, NULL, 0, G_MAXDOUBLE, 0, G_PARAM_READABLE));
g_param_spec_double ("energy-empty", NULL, NULL, 0, G_MAXDOUBLE, 0, G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_BATTERY_ENERGY_FULL,
g_param_spec_double ("battery-energy-full", NULL, NULL, 0, G_MAXDOUBLE, 0, G_PARAM_READABLE));
g_param_spec_double ("energy-full", NULL, NULL, 0, G_MAXDOUBLE, 0, G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_BATTERY_ENERGY_FULL_DESIGN,
g_param_spec_double ("battery-energy-full-design", NULL, NULL, 0, G_MAXDOUBLE, 0, G_PARAM_READABLE));
g_param_spec_double ("energy-full-design", NULL, NULL, 0, G_MAXDOUBLE, 0, G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_BATTERY_ENERGY_RATE,
g_param_spec_double ("battery-energy-rate", NULL, NULL, -G_MAXDOUBLE, G_MAXDOUBLE, 0, G_PARAM_READABLE));
g_param_spec_double ("energy-rate", NULL, NULL, -G_MAXDOUBLE, G_MAXDOUBLE, 0, G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_BATTERY_TIME_TO_EMPTY,
g_param_spec_int64 ("battery-time-to-empty", NULL, NULL, -1, G_MAXINT64, -1, G_PARAM_READABLE));
g_param_spec_int64 ("time-to-empty", NULL, NULL, -1, G_MAXINT64, -1, G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_BATTERY_TIME_TO_FULL,
g_param_spec_int64 ("battery-time-to-full", NULL, NULL, -1, G_MAXINT64, -1, G_PARAM_READABLE));
g_param_spec_int64 ("time-to-full", NULL, NULL, -1, G_MAXINT64, -1, G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_BATTERY_PERCENTAGE,
g_param_spec_double ("battery-percentage", NULL, NULL, -1, 100, -1, G_PARAM_READABLE));
g_param_spec_double ("percentage", NULL, NULL, -1, 100, -1, G_PARAM_READABLE));
g_object_class_install_property (
object_class,
PROP_BATTERY_TECHNOLOGY,
g_param_spec_string ("battery-technology", NULL, NULL, NULL, G_PARAM_READABLE));
g_param_spec_string ("technology", NULL, NULL, NULL, G_PARAM_READABLE));
dbus_g_error_domain_register (DKP_DEVICE_ERROR, NULL, DKP_DEVICE_TYPE_ERROR);
}

20
src/dkp-hid.c
View file

@ -179,31 +179,31 @@ dkp_hid_set_obj (DkpHid *hid, int code, int value)
switch (code) {
case DKP_HID_REMAINING_CAPACITY:
obj->battery_percentage = value;
obj->percentage = value;
break;
case DKP_HID_RUNTIME_TO_EMPTY:
obj->battery_time_to_empty = value;
obj->time_to_empty = value;
break;
case DKP_HID_CHARGING:
if (value != 0)
obj->battery_state = DKP_DEVICE_STATE_CHARGING;
obj->state = DKP_DEVICE_STATE_CHARGING;
break;
case DKP_HID_DISCHARGING:
if (value != 0)
obj->battery_state = DKP_DEVICE_STATE_DISCHARGING;
obj->state = DKP_DEVICE_STATE_DISCHARGING;
break;
case DKP_HID_BATTERY_PRESENT:
obj->battery_is_present = (value != 0);
obj->is_present = (value != 0);
break;
case DKP_HID_DEVICE_NAME:
//obj->device_name = dkp_hid_get_string (hid, value);
break;
case DKP_HID_CHEMISTRY:
type = dkp_hid_get_string (hid, value);
obj->battery_technology = dkp_acpi_to_device_technology (type);
obj->technology = dkp_acpi_to_device_technology (type);
break;
case DKP_HID_RECHARGEABLE:
obj->battery_is_rechargeable = (value != 0);
obj->is_rechargeable = (value != 0);
break;
case DKP_HID_OEM_INFORMATION:
obj->vendor = g_strdup (dkp_hid_get_string (hid, value));
@ -215,7 +215,7 @@ dkp_hid_set_obj (DkpHid *hid, int code, int value)
obj->serial = g_strdup (dkp_hid_get_string (hid, value));
break;
case DKP_HID_DESIGN_CAPACITY:
obj->battery_energy_full_design = value;
obj->energy_full_design = value;
break;
default:
ret = FALSE;
@ -315,9 +315,9 @@ dkp_hid_coldplug (DkpDevice *device)
/* hardcode some values */
obj->type = DKP_DEVICE_TYPE_UPS;
obj->battery_is_rechargeable = TRUE;
obj->is_rechargeable = TRUE;
obj->power_supply = TRUE;
obj->battery_is_present = TRUE;
obj->is_present = TRUE;
/* try and get from udev if UPS is being difficult */
if (obj->vendor == NULL)

146
src/dkp-supply.c
View file

@ -46,8 +46,8 @@ struct DkpSupplyPrivate
DkpHistory *history;
guint poll_timer_id;
gboolean has_coldplug_values;
gdouble battery_energy_old;
GTimeVal battery_energy_old_timespec;
gdouble energy_old;
GTimeVal energy_old_timespec;
};
static void dkp_supply_class_init (DkpSupplyClass *klass);
@ -70,7 +70,7 @@ dkp_supply_refresh_line_power (DkpSupply *supply)
obj->power_supply = TRUE;
/* get new AC value */
obj->line_power_online = sysfs_get_int (obj->native_path, "online");
obj->online = sysfs_get_int (obj->native_path, "online");
return TRUE;
}
@ -91,8 +91,8 @@ dkp_supply_reset_values (DkpSupply *supply)
native_path = g_strdup (obj->native_path);
supply->priv->has_coldplug_values = FALSE;
supply->priv->battery_energy_old = -1;
supply->priv->battery_energy_old_timespec.tv_sec = 0;
supply->priv->energy_old = -1;
supply->priv->energy_old_timespec.tv_sec = 0;
dkp_object_clear (obj);
/* restore the saved stuff */
@ -114,10 +114,10 @@ dkp_supply_get_on_battery (DkpDevice *device, gboolean *on_battery)
if (obj->type != DKP_DEVICE_TYPE_BATTERY)
return FALSE;
if (!obj->battery_is_present)
if (!obj->is_present)
return FALSE;
*on_battery = (obj->battery_state == DKP_DEVICE_STATE_DISCHARGING);
*on_battery = (obj->state == DKP_DEVICE_STATE_DISCHARGING);
return TRUE;
}
@ -146,15 +146,15 @@ dkp_supply_get_low_battery (DkpDevice *device, gboolean *low_battery)
return TRUE;
}
*low_battery = (obj->battery_percentage < 10);
*low_battery = (obj->percentage < 10);
return TRUE;
}
/**
* dkp_supply_calculate_battery_rate:
* dkp_supply_calculate_rate:
**/
static void
dkp_supply_calculate_battery_rate (DkpSupply *supply)
dkp_supply_calculate_rate (DkpSupply *supply)
{
guint time;
gdouble energy;
@ -162,29 +162,29 @@ dkp_supply_calculate_battery_rate (DkpSupply *supply)
DkpDevice *device = DKP_DEVICE (supply);
DkpObject *obj = dkp_device_get_obj (device);
if (obj->battery_energy < 0)
if (obj->energy < 0)
return;
if (supply->priv->battery_energy_old < 0)
if (supply->priv->energy_old < 0)
return;
if (supply->priv->battery_energy_old == obj->battery_energy)
if (supply->priv->energy_old == obj->energy)
return;
/* get the time difference */
g_get_current_time (&now);
time = now.tv_sec - supply->priv->battery_energy_old_timespec.tv_sec;
time = now.tv_sec - supply->priv->energy_old_timespec.tv_sec;
if (time == 0)
return;
/* get the difference in charge */
energy = supply->priv->battery_energy_old - obj->battery_energy;
energy = supply->priv->energy_old - obj->energy;
if (energy < 0.1)
return;
/* probably okay */
obj->battery_energy_rate = energy * 3600 / time;
obj->energy_rate = energy * 3600 / time;
}
/**
@ -197,13 +197,13 @@ dkp_supply_refresh_battery (DkpSupply *supply)
{
gchar *status = NULL;
gboolean ret = TRUE;
DkpDeviceState battery_state;
DkpDeviceState state;
DkpDevice *device = DKP_DEVICE (supply);
DkpObject *obj = dkp_device_get_obj (device);
/* have we just been removed? */
obj->battery_is_present = sysfs_get_bool (obj->native_path, "present");
if (!obj->battery_is_present) {
obj->is_present = sysfs_get_bool (obj->native_path, "present");
if (!obj->is_present) {
dkp_supply_reset_values (supply);
obj->type = DKP_DEVICE_TYPE_BATTERY;
goto out;
@ -218,7 +218,7 @@ dkp_supply_refresh_battery (DkpSupply *supply)
/* the ACPI spec is bad at defining battery type constants */
technology_native = g_strstrip (sysfs_get_string (obj->native_path, "technology"));
obj->battery_technology = dkp_acpi_to_device_technology (technology_native);
obj->technology = dkp_acpi_to_device_technology (technology_native);
g_free (technology_native);
obj->vendor = g_strstrip (sysfs_get_string (obj->native_path, "manufacturer"));
@ -226,24 +226,24 @@ dkp_supply_refresh_battery (DkpSupply *supply)
obj->serial = g_strstrip (sysfs_get_string (obj->native_path, "serial_number"));
/* assume true for laptops */
obj->battery_is_rechargeable = TRUE;
obj->is_rechargeable = TRUE;
/* these don't change at runtime */
obj->battery_energy_full =
obj->energy_full =
sysfs_get_double (obj->native_path, "energy_full") / 1000000.0;
obj->battery_energy_full_design =
obj->energy_full_design =
sysfs_get_double (obj->native_path, "energy_full_design") / 1000000.0;
/* the last full cannot be bigger than the design */
if (obj->battery_energy_full > obj->battery_energy_full_design)
obj->battery_energy_full = obj->battery_energy_full_design;
if (obj->energy_full > obj->energy_full_design)
obj->energy_full = obj->energy_full_design;
/* calculate how broken our battery is */
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;
obj->capacity = obj->energy_full_design / obj->energy_full * 100.0f;
if (obj->capacity < 0)
obj->capacity = 0;
if (obj->capacity > 100.0)
obj->capacity = 100.0;
/* we only coldplug once, as these values will never change */
supply->priv->has_coldplug_values = TRUE;
@ -251,86 +251,86 @@ dkp_supply_refresh_battery (DkpSupply *supply)
status = g_strstrip (sysfs_get_string (obj->native_path, "status"));
if (strcasecmp (status, "charging") == 0)
battery_state = DKP_DEVICE_STATE_CHARGING;
state = DKP_DEVICE_STATE_CHARGING;
else if (strcasecmp (status, "discharging") == 0)
battery_state = DKP_DEVICE_STATE_DISCHARGING;
state = DKP_DEVICE_STATE_DISCHARGING;
else if (strcasecmp (status, "full") == 0)
battery_state = DKP_DEVICE_STATE_FULLY_CHARGED;
state = DKP_DEVICE_STATE_FULLY_CHARGED;
else if (strcasecmp (status, "empty") == 0)
battery_state = DKP_DEVICE_STATE_EMPTY;
state = DKP_DEVICE_STATE_EMPTY;
else {
dkp_warning ("unknown status string: %s", status);
battery_state = DKP_DEVICE_STATE_UNKNOWN;
state = DKP_DEVICE_STATE_UNKNOWN;
}
/* get the currect charge */
obj->battery_energy =
obj->energy =
sysfs_get_double (obj->native_path, "energy_avg") / 1000000.0;
if (obj->battery_energy == 0)
obj->battery_energy =
if (obj->energy == 0)
obj->energy =
sysfs_get_double (obj->native_path, "energy_now") / 1000000.0;
/* some batteries don't update last_full attribute */
if (obj->battery_energy > obj->battery_energy_full)
obj->battery_energy_full = obj->battery_energy;
if (obj->energy > obj->energy_full)
obj->energy_full = obj->energy;
obj->battery_energy_rate =
obj->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 (obj->battery_energy_rate == 0xffff)
obj->battery_energy_rate = -1;
if (obj->energy_rate == 0xffff)
obj->energy_rate = -1;
/* sanity check to less than 100W */
if (obj->battery_energy_rate > 100*1000)
obj->battery_energy_rate = -1;
if (obj->energy_rate > 100*1000)
obj->energy_rate = -1;
/* the hardware reporting failed -- try to calculate this */
if (obj->battery_energy_rate < 0) {
dkp_supply_calculate_battery_rate (supply);
if (obj->energy_rate < 0) {
dkp_supply_calculate_rate (supply);
}
/* get a precise percentage */
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;
obj->percentage = 100.0 * obj->energy / obj->energy_full;
if (obj->percentage < 0)
obj->percentage = 0;
if (obj->percentage > 100.0)
obj->percentage = 100.0;
/* calculate a quick and dirty time remaining value */
obj->battery_time_to_empty = -1;
obj->battery_time_to_full = -1;
if (obj->battery_energy_rate > 0) {
if (battery_state == DKP_DEVICE_STATE_DISCHARGING) {
obj->battery_time_to_empty = 3600 * (obj->battery_energy / obj->battery_energy_rate);
} else if (battery_state == DKP_DEVICE_STATE_CHARGING) {
obj->battery_time_to_full = 3600 * ((obj->battery_energy_full - obj->battery_energy) / obj->battery_energy_rate);
obj->time_to_empty = -1;
obj->time_to_full = -1;
if (obj->energy_rate > 0) {
if (state == DKP_DEVICE_STATE_DISCHARGING) {
obj->time_to_empty = 3600 * (obj->energy / obj->energy_rate);
} else if (state == DKP_DEVICE_STATE_CHARGING) {
obj->time_to_full = 3600 * ((obj->energy_full - obj->energy) / obj->energy_rate);
}
}
/* check the remaining time is under a set limit, to deal with broken
primary batteries rate */
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;
if (obj->time_to_empty > (100 * 60 * 60))
obj->time_to_empty = -1;
if (obj->time_to_full > (100 * 60 * 60))
obj->time_to_full = -1;
/* set the old status */
supply->priv->battery_energy_old = obj->battery_energy;
g_get_current_time (&supply->priv->battery_energy_old_timespec);
supply->priv->energy_old = obj->energy;
g_get_current_time (&supply->priv->energy_old_timespec);
/* we changed state */
if (obj->battery_state != battery_state) {
supply->priv->battery_energy_old = -1;
obj->battery_state = battery_state;
if (obj->state != state) {
supply->priv->energy_old = -1;
obj->state = state;
}
out:
/* save new history */
dkp_history_set_state (supply->priv->history, obj->battery_state);
dkp_history_set_charge_data (supply->priv->history, obj->battery_percentage);
dkp_history_set_rate_data (supply->priv->history, obj->battery_energy_rate);
dkp_history_set_state (supply->priv->history, obj->state);
dkp_history_set_charge_data (supply->priv->history, obj->percentage);
dkp_history_set_rate_data (supply->priv->history, obj->energy_rate);
g_free (status);
return ret;
@ -445,8 +445,8 @@ dkp_supply_refresh (DkpDevice *device)
/* Seems that we don't get change uevents from the
* kernel on some BIOS types; set up a timer to poll
* if we are charging or discharging */
if (obj->battery_state == DKP_DEVICE_STATE_CHARGING ||
obj->battery_state == DKP_DEVICE_STATE_DISCHARGING)
if (obj->state == DKP_DEVICE_STATE_CHARGING ||
obj->state == DKP_DEVICE_STATE_DISCHARGING)
supply->priv->poll_timer_id =
g_timeout_add_seconds (DKP_SUPPLY_REFRESH_TIMEOUT,
(GSourceFunc) dkp_supply_poll_battery, supply);

8
src/dkp-wup.c
View file

@ -251,8 +251,8 @@ dkp_wup_parse_command (DkpWup *wup, const gchar *data)
/* update the command fields */
if (command == '?' && subcommand == '-') {
obj->battery_energy_rate = strtod (tokens[offset+DKP_WUP_RESPONSE_HEADER_WATTS], NULL);
// obj->battery_volts = strtod (tokens[offset+DKP_WUP_RESPONSE_HEADER_VOLTS], NULL);
obj->energy_rate = strtod (tokens[offset+DKP_WUP_RESPONSE_HEADER_WATTS], NULL);
// obj->volts = strtod (tokens[offset+DKP_WUP_RESPONSE_HEADER_VOLTS], NULL);
} else {
dkp_debug ("ignoring command '%c'", command);
}
@ -322,9 +322,9 @@ dkp_wup_coldplug (DkpDevice *device)
/* hardcode some values */
obj->type = DKP_DEVICE_TYPE_MONITOR;
obj->battery_is_rechargeable = FALSE;
obj->is_rechargeable = FALSE;
obj->power_supply = FALSE;
obj->battery_is_present = FALSE;
obj->is_present = FALSE;
obj->vendor = g_strdup (devkit_device_get_property (d, "ID_VENDOR"));
/* coldplug everything */

46
src/org.freedesktop.DeviceKit.Power.Device.xml
View file

@ -10,7 +10,7 @@
<doc:para>
TODO: some explanatory text etc. etc. Mention that we
collect history to provide more precise values of
battery-time-to-empty, battery-time-to-full. Go into detail
time-to-empty, time-to-full. Go into detail
with the algorithms.
</doc:para>
<doc:para>
@ -194,7 +194,7 @@
</doc:para></doc:description></doc:doc>
</property>
<property name="line-power-online" type="b" access="read">
<property name="online" type="b" access="read">
<doc:doc><doc:description><doc:para>
Whether power is currently being provided through line power.
This property is only valid if the property
@ -203,7 +203,7 @@
</doc:para></doc:description></doc:doc>
</property>
<property name="battery-energy" type="d" access="read">
<property name="energy" type="d" access="read">
<doc:doc><doc:description><doc:para>
Amount of energy (measured in Wh) currently available in
the power source.
@ -214,7 +214,7 @@
</doc:para></doc:description></doc:doc>
</property>
<property name="battery-energy-empty" type="d" access="read">
<property name="energy-empty" type="d" access="read">
<doc:doc><doc:description><doc:para>
Amount of energy (measured in Wh) in the power source when
it's considered to be empty.
@ -225,7 +225,7 @@
</doc:para></doc:description></doc:doc>
</property>
<property name="battery-energy-full" type="d" access="read">
<property name="energy-full" type="d" access="read">
<doc:doc><doc:description><doc:para>
Amount of energy (measured in Wh) in the power source when
it's considered full.
@ -236,7 +236,7 @@
</doc:para></doc:description></doc:doc>
</property>
<property name="battery-energy-full-design" type="d" access="read">
<property name="energy-full-design" type="d" access="read">
<doc:doc><doc:description><doc:para>
Amount of energy (measured in Wh) the power source is
designed to hold when it's considered full.
@ -247,7 +247,7 @@
</doc:para></doc:description></doc:doc>
</property>
<property name="battery-energy-rate" type="d" access="read">
<property name="energy-rate" type="d" access="read">
<doc:doc><doc:description><doc:para>
Amount of energy being drained from the source, measured
in W. If positive, the source is being discharged, if
@ -259,7 +259,7 @@
</doc:para></doc:description></doc:doc>
</property>
<property name="battery-time-to-empty" type="x" access="read">
<property name="time-to-empty" type="x" access="read">
<doc:doc><doc:description><doc:para>
Number of seconds until the power source is considered empty.
Is set to -1 if unknown.
@ -270,7 +270,7 @@
</doc:para></doc:description></doc:doc>
</property>
<property name="battery-time-to-full" type="x" access="read">
<property name="time-to-full" type="x" access="read">
<doc:doc><doc:description><doc:para>
Number of seconds until the power source is considered full.
Is set to -1 if unknown.
@ -281,16 +281,16 @@
</doc:para></doc:description></doc:doc>
</property>
<property name="battery-percentage" type="d" access="read">
<property name="percentage" type="d" access="read">
<doc:doc><doc:description><doc:para>
The amount of energy left in the power source expressed as
a percentage between 0 and 100. Typically this is the same as
(<doc:ref type="property" to="Source:battery-energy">battery-energy</doc:ref> -
<doc:ref type="property" to="Source:battery-energy-empty">battery-energy-empty</doc:ref>) /
(<doc:ref type="property" to="Source:battery-energy-full">battery-energy-full</doc:ref> -
<doc:ref type="property" to="Source:battery-energy-empty">battery-energy-empty</doc:ref>).
(<doc:ref type="property" to="Source:energy">energy</doc:ref> -
<doc:ref type="property" to="Source:energy-empty">energy-empty</doc:ref>) /
(<doc:ref type="property" to="Source:energy-full">energy-full</doc:ref> -
<doc:ref type="property" to="Source:energy-empty">energy-empty</doc:ref>).
However, some primitive power sources are capable of only
reporting percentages and in this case the battery-energy-*
reporting percentages and in this case the energy-*
properties will be unset while this property is set.
</doc:para><doc:para>
This property is only valid if the property
@ -299,7 +299,7 @@
</doc:para></doc:description></doc:doc>
</property>
<property name="battery-is-present" type="b" access="read">
<property name="is-present" type="b" access="read">
<doc:doc><doc:description><doc:para>
If the power source is present in the bay.
This field is required as some batteries are hot-removable, for example
@ -311,7 +311,7 @@
</doc:para></doc:description></doc:doc>
</property>
<property name="battery-state" type="s" access="read">
<property name="state" type="s" access="read">
<doc:doc><doc:description><doc:para>
The battery power state.
Known values are "fully-charged", "empty", "charging",
@ -323,7 +323,7 @@
</doc:para></doc:description></doc:doc>
</property>
<property name="battery-is-rechargeable" type="b" access="read">
<property name="is-rechargeable" type="b" access="read">
<doc:doc><doc:description><doc:para>
If the power source is rechargeable.
</doc:para><doc:para>
@ -333,16 +333,16 @@
</doc:para></doc:description></doc:doc>
</property>
<property name="battery-capacity" type="d" access="read">
<property name="capacity" type="d" access="read">
<doc:doc><doc:description><doc:para>
The capacity of the power source expressed as a percentage between 0 and 100.
The capacity of the battery will reduce with age.
A capacity value less than 75% is usually a sign that you should renew your battery.
Typically this value is the same as
(<doc:ref type="property" to="Source:battery-full-design">battery-full-design</doc:ref> /
<doc:ref type="property" to="Source:battery-full">battery-full</doc:ref>) * 100.
(<doc:ref type="property" to="Source:full-design">full-design</doc:ref> /
<doc:ref type="property" to="Source:full">full</doc:ref>) * 100.
However, some primitive power sources are not capable reporting capacity
and in this case the battery-capacity property will be unset.
and in this case the capacity property will be unset.
</doc:para><doc:para>
This property is only valid if the property
<doc:ref type="property" to="Source:type">type</doc:ref>
@ -350,7 +350,7 @@
</doc:para></doc:description></doc:doc>
</property>
<property name="battery-technology" type="s" access="read">
<property name="technology" type="s" access="read">
<doc:doc><doc:description><doc:para>
Technology used in the battery; known values are "lithium-ion", "lead-acid",
"lithium-polymer", "nickel-metal-hydride", "lithium-iron-phosphate" or "unknown".