mirror of
https://gitlab.freedesktop.org/upower/upower.git
synced 2026-02-04 02:30:27 +01:00
the enums of of DkpDevice origin, not DkpSource
This commit is contained in:
Richard Hughes
parent
a0be0fea17
commit
72a13ae91d
12 changed files with 185 additions and 185 deletions
|
|
@ -25,35 +25,35 @@
|
|||
#include "dkp-enum.h"
|
||||
|
||||
/**
|
||||
* dkp_source_type_to_text:
|
||||
* dkp_device_type_to_text:
|
||||
**/
|
||||
const gchar *
|
||||
dkp_source_type_to_text (DkpSourceType type_enum)
|
||||
dkp_device_type_to_text (DkpDeviceType type_enum)
|
||||
{
|
||||
const gchar *type = NULL;
|
||||
switch (type_enum) {
|
||||
case DKP_SOURCE_TYPE_LINE_POWER:
|
||||
case DKP_DEVICE_TYPE_LINE_POWER:
|
||||
type = "line-power";
|
||||
break;
|
||||
case DKP_SOURCE_TYPE_BATTERY:
|
||||
case DKP_DEVICE_TYPE_BATTERY:
|
||||
type = "battery";
|
||||
break;
|
||||
case DKP_SOURCE_TYPE_UPS:
|
||||
case DKP_DEVICE_TYPE_UPS:
|
||||
type = "ups";
|
||||
break;
|
||||
case DKP_SOURCE_TYPE_MOUSE:
|
||||
case DKP_DEVICE_TYPE_MOUSE:
|
||||
type = "mouse";
|
||||
break;
|
||||
case DKP_SOURCE_TYPE_KEYBOARD:
|
||||
case DKP_DEVICE_TYPE_KEYBOARD:
|
||||
type = "keyboard";
|
||||
break;
|
||||
case DKP_SOURCE_TYPE_PDA:
|
||||
case DKP_DEVICE_TYPE_PDA:
|
||||
type = "pda";
|
||||
break;
|
||||
case DKP_SOURCE_TYPE_PHONE:
|
||||
case DKP_DEVICE_TYPE_PHONE:
|
||||
type = "phone";
|
||||
break;
|
||||
case DKP_SOURCE_TYPE_UNKNOWN:
|
||||
case DKP_DEVICE_TYPE_UNKNOWN:
|
||||
type = "unknown";
|
||||
break;
|
||||
default:
|
||||
|
|
@ -64,51 +64,51 @@ dkp_source_type_to_text (DkpSourceType type_enum)
|
|||
}
|
||||
|
||||
/**
|
||||
* dkp_source_type_from_text:
|
||||
* dkp_device_type_from_text:
|
||||
**/
|
||||
DkpSourceType
|
||||
dkp_source_type_from_text (const gchar *type)
|
||||
DkpDeviceType
|
||||
dkp_device_type_from_text (const gchar *type)
|
||||
{
|
||||
if (type == NULL)
|
||||
return DKP_SOURCE_TYPE_UNKNOWN;
|
||||
return DKP_DEVICE_TYPE_UNKNOWN;
|
||||
if (strcmp (type, "line-power") == 0)
|
||||
return DKP_SOURCE_TYPE_LINE_POWER;
|
||||
return DKP_DEVICE_TYPE_LINE_POWER;
|
||||
if (strcmp (type, "battery") == 0)
|
||||
return DKP_SOURCE_TYPE_BATTERY;
|
||||
return DKP_DEVICE_TYPE_BATTERY;
|
||||
if (strcmp (type, "ups") == 0)
|
||||
return DKP_SOURCE_TYPE_UPS;
|
||||
return DKP_DEVICE_TYPE_UPS;
|
||||
if (strcmp (type, "mouse") == 0)
|
||||
return DKP_SOURCE_TYPE_MOUSE;
|
||||
return DKP_DEVICE_TYPE_MOUSE;
|
||||
if (strcmp (type, "keyboard") == 0)
|
||||
return DKP_SOURCE_TYPE_KEYBOARD;
|
||||
return DKP_DEVICE_TYPE_KEYBOARD;
|
||||
if (strcmp (type, "pda") == 0)
|
||||
return DKP_SOURCE_TYPE_PDA;
|
||||
return DKP_DEVICE_TYPE_PDA;
|
||||
if (strcmp (type, "phone") == 0)
|
||||
return DKP_SOURCE_TYPE_PHONE;
|
||||
return DKP_SOURCE_TYPE_UNKNOWN;
|
||||
return DKP_DEVICE_TYPE_PHONE;
|
||||
return DKP_DEVICE_TYPE_UNKNOWN;
|
||||
}
|
||||
|
||||
/**
|
||||
* dkp_source_state_to_text:
|
||||
* dkp_device_state_to_text:
|
||||
**/
|
||||
const gchar *
|
||||
dkp_source_state_to_text (DkpSourceState state_enum)
|
||||
dkp_device_state_to_text (DkpDeviceState state_enum)
|
||||
{
|
||||
const gchar *state = NULL;
|
||||
switch (state_enum) {
|
||||
case DKP_SOURCE_STATE_CHARGING:
|
||||
case DKP_DEVICE_STATE_CHARGING:
|
||||
state = "charging";
|
||||
break;
|
||||
case DKP_SOURCE_STATE_DISCHARGING:
|
||||
case DKP_DEVICE_STATE_DISCHARGING:
|
||||
state = "discharging";
|
||||
break;
|
||||
case DKP_SOURCE_STATE_EMPTY:
|
||||
case DKP_DEVICE_STATE_EMPTY:
|
||||
state = "empty";
|
||||
break;
|
||||
case DKP_SOURCE_STATE_FULLY_CHARGED:
|
||||
case DKP_DEVICE_STATE_FULLY_CHARGED:
|
||||
state = "fully-charged";
|
||||
break;
|
||||
case DKP_SOURCE_STATE_UNKNOWN:
|
||||
case DKP_DEVICE_STATE_UNKNOWN:
|
||||
state = "unknown";
|
||||
break;
|
||||
default:
|
||||
|
|
@ -119,51 +119,51 @@ dkp_source_state_to_text (DkpSourceState state_enum)
|
|||
}
|
||||
|
||||
/**
|
||||
* dkp_source_state_from_text:
|
||||
* dkp_device_state_from_text:
|
||||
**/
|
||||
DkpSourceState
|
||||
dkp_source_state_from_text (const gchar *state)
|
||||
DkpDeviceState
|
||||
dkp_device_state_from_text (const gchar *state)
|
||||
{
|
||||
if (state == NULL)
|
||||
return DKP_SOURCE_STATE_UNKNOWN;
|
||||
return DKP_DEVICE_STATE_UNKNOWN;
|
||||
if (strcmp (state, "charging") == 0)
|
||||
return DKP_SOURCE_STATE_CHARGING;
|
||||
return DKP_DEVICE_STATE_CHARGING;
|
||||
if (strcmp (state, "discharging") == 0)
|
||||
return DKP_SOURCE_STATE_DISCHARGING;
|
||||
return DKP_DEVICE_STATE_DISCHARGING;
|
||||
if (strcmp (state, "empty") == 0)
|
||||
return DKP_SOURCE_STATE_EMPTY;
|
||||
return DKP_DEVICE_STATE_EMPTY;
|
||||
if (strcmp (state, "fully-charged") == 0)
|
||||
return DKP_SOURCE_STATE_FULLY_CHARGED;
|
||||
return DKP_SOURCE_STATE_UNKNOWN;
|
||||
return DKP_DEVICE_STATE_FULLY_CHARGED;
|
||||
return DKP_DEVICE_STATE_UNKNOWN;
|
||||
}
|
||||
|
||||
/**
|
||||
* dkp_source_technology_to_text:
|
||||
* dkp_device_technology_to_text:
|
||||
**/
|
||||
const gchar *
|
||||
dkp_source_technology_to_text (DkpSourceTechnology technology_enum)
|
||||
dkp_device_technology_to_text (DkpDeviceTechnology technology_enum)
|
||||
{
|
||||
const gchar *technology = NULL;
|
||||
switch (technology_enum) {
|
||||
case DKP_SOURCE_TECHNOLGY_LITHIUM_ION:
|
||||
case DKP_DEVICE_TECHNOLGY_LITHIUM_ION:
|
||||
technology = "lithium-ion";
|
||||
break;
|
||||
case DKP_SOURCE_TECHNOLGY_LITHIUM_POLYMER:
|
||||
case DKP_DEVICE_TECHNOLGY_LITHIUM_POLYMER:
|
||||
technology = "lithium-polymer";
|
||||
break;
|
||||
case DKP_SOURCE_TECHNOLGY_LITHIUM_IRON_PHOSPHATE:
|
||||
case DKP_DEVICE_TECHNOLGY_LITHIUM_IRON_PHOSPHATE:
|
||||
technology = "lithium-iron-phosphate";
|
||||
break;
|
||||
case DKP_SOURCE_TECHNOLGY_LEAD_ACID:
|
||||
case DKP_DEVICE_TECHNOLGY_LEAD_ACID:
|
||||
technology = "lead-acid";
|
||||
break;
|
||||
case DKP_SOURCE_TECHNOLGY_NICKEL_CADMIUM:
|
||||
case DKP_DEVICE_TECHNOLGY_NICKEL_CADMIUM:
|
||||
technology = "nickel-cadmium";
|
||||
break;
|
||||
case DKP_SOURCE_TECHNOLGY_NICKEL_METAL_HYDRIDE:
|
||||
case DKP_DEVICE_TECHNOLGY_NICKEL_METAL_HYDRIDE:
|
||||
technology = "nickel-metal-hydride";
|
||||
break;
|
||||
case DKP_SOURCE_TECHNOLGY_UNKNOWN:
|
||||
case DKP_DEVICE_TECHNOLGY_UNKNOWN:
|
||||
technology = "unknown";
|
||||
break;
|
||||
default:
|
||||
|
|
@ -174,56 +174,56 @@ dkp_source_technology_to_text (DkpSourceTechnology technology_enum)
|
|||
}
|
||||
|
||||
/**
|
||||
* dkp_source_technology_from_text:
|
||||
* dkp_device_technology_from_text:
|
||||
**/
|
||||
DkpSourceTechnology
|
||||
dkp_source_technology_from_text (const gchar *technology)
|
||||
DkpDeviceTechnology
|
||||
dkp_device_technology_from_text (const gchar *technology)
|
||||
{
|
||||
if (technology == NULL)
|
||||
return DKP_SOURCE_TECHNOLGY_UNKNOWN;
|
||||
return DKP_DEVICE_TECHNOLGY_UNKNOWN;
|
||||
if (strcmp (technology, "lithium-ion") == 0)
|
||||
return DKP_SOURCE_TECHNOLGY_LITHIUM_ION;
|
||||
return DKP_DEVICE_TECHNOLGY_LITHIUM_ION;
|
||||
if (strcmp (technology, "lithium-polymer") == 0)
|
||||
return DKP_SOURCE_TECHNOLGY_LITHIUM_POLYMER;
|
||||
return DKP_DEVICE_TECHNOLGY_LITHIUM_POLYMER;
|
||||
if (strcmp (technology, "lithium-iron-phosphate") == 0)
|
||||
return DKP_SOURCE_TECHNOLGY_LITHIUM_IRON_PHOSPHATE;
|
||||
return DKP_DEVICE_TECHNOLGY_LITHIUM_IRON_PHOSPHATE;
|
||||
if (strcmp (technology, "lead-acid") == 0)
|
||||
return DKP_SOURCE_TECHNOLGY_LEAD_ACID;
|
||||
return DKP_DEVICE_TECHNOLGY_LEAD_ACID;
|
||||
if (strcmp (technology, "nickel-cadmium") == 0)
|
||||
return DKP_SOURCE_TECHNOLGY_NICKEL_CADMIUM;
|
||||
return DKP_DEVICE_TECHNOLGY_NICKEL_CADMIUM;
|
||||
if (strcmp (technology, "nickel-metal-hydride") == 0)
|
||||
return DKP_SOURCE_TECHNOLGY_NICKEL_METAL_HYDRIDE;
|
||||
return DKP_SOURCE_TECHNOLGY_UNKNOWN;
|
||||
return DKP_DEVICE_TECHNOLGY_NICKEL_METAL_HYDRIDE;
|
||||
return DKP_DEVICE_TECHNOLGY_UNKNOWN;
|
||||
}
|
||||
|
||||
/**
|
||||
* dkp_acpi_to_source_technology:
|
||||
* dkp_acpi_to_device_technology:
|
||||
**/
|
||||
DkpSourceTechnology
|
||||
dkp_acpi_to_source_technology (const gchar *type)
|
||||
DkpDeviceTechnology
|
||||
dkp_acpi_to_device_technology (const gchar *type)
|
||||
{
|
||||
if (type == NULL) {
|
||||
return DKP_SOURCE_TECHNOLGY_UNKNOWN;
|
||||
return DKP_DEVICE_TECHNOLGY_UNKNOWN;
|
||||
}
|
||||
/* every case combination of Li-Ion is commonly used.. */
|
||||
if (strcasecmp (type, "li-ion") == 0 ||
|
||||
strcasecmp (type, "lion") == 0) {
|
||||
return DKP_SOURCE_TECHNOLGY_LITHIUM_ION;
|
||||
return DKP_DEVICE_TECHNOLGY_LITHIUM_ION;
|
||||
}
|
||||
if (strcasecmp (type, "pb") == 0 ||
|
||||
strcasecmp (type, "pbac") == 0) {
|
||||
return DKP_SOURCE_TECHNOLGY_LEAD_ACID;
|
||||
return DKP_DEVICE_TECHNOLGY_LEAD_ACID;
|
||||
}
|
||||
if (strcasecmp (type, "lip") == 0 ||
|
||||
strcasecmp (type, "lipo") == 0) {
|
||||
return DKP_SOURCE_TECHNOLGY_LITHIUM_POLYMER;
|
||||
return DKP_DEVICE_TECHNOLGY_LITHIUM_POLYMER;
|
||||
}
|
||||
if (strcasecmp (type, "nimh") == 0) {
|
||||
return DKP_SOURCE_TECHNOLGY_NICKEL_METAL_HYDRIDE;
|
||||
return DKP_DEVICE_TECHNOLGY_NICKEL_METAL_HYDRIDE;
|
||||
}
|
||||
if (strcasecmp (type, "lifo") == 0) {
|
||||
return DKP_SOURCE_TECHNOLGY_LITHIUM_IRON_PHOSPHATE;
|
||||
return DKP_DEVICE_TECHNOLGY_LITHIUM_IRON_PHOSPHATE;
|
||||
}
|
||||
return DKP_SOURCE_TECHNOLGY_UNKNOWN;
|
||||
return DKP_DEVICE_TECHNOLGY_UNKNOWN;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -27,41 +27,41 @@
|
|||
G_BEGIN_DECLS
|
||||
|
||||
typedef enum {
|
||||
DKP_SOURCE_TYPE_LINE_POWER,
|
||||
DKP_SOURCE_TYPE_BATTERY,
|
||||
DKP_SOURCE_TYPE_UPS,
|
||||
DKP_SOURCE_TYPE_MOUSE,
|
||||
DKP_SOURCE_TYPE_KEYBOARD,
|
||||
DKP_SOURCE_TYPE_PDA,
|
||||
DKP_SOURCE_TYPE_PHONE,
|
||||
DKP_SOURCE_TYPE_UNKNOWN
|
||||
} DkpSourceType;
|
||||
DKP_DEVICE_TYPE_LINE_POWER,
|
||||
DKP_DEVICE_TYPE_BATTERY,
|
||||
DKP_DEVICE_TYPE_UPS,
|
||||
DKP_DEVICE_TYPE_MOUSE,
|
||||
DKP_DEVICE_TYPE_KEYBOARD,
|
||||
DKP_DEVICE_TYPE_PDA,
|
||||
DKP_DEVICE_TYPE_PHONE,
|
||||
DKP_DEVICE_TYPE_UNKNOWN
|
||||
} DkpDeviceType;
|
||||
|
||||
typedef enum {
|
||||
DKP_SOURCE_STATE_CHARGING,
|
||||
DKP_SOURCE_STATE_DISCHARGING,
|
||||
DKP_SOURCE_STATE_EMPTY,
|
||||
DKP_SOURCE_STATE_FULLY_CHARGED,
|
||||
DKP_SOURCE_STATE_UNKNOWN
|
||||
} DkpSourceState;
|
||||
DKP_DEVICE_STATE_CHARGING,
|
||||
DKP_DEVICE_STATE_DISCHARGING,
|
||||
DKP_DEVICE_STATE_EMPTY,
|
||||
DKP_DEVICE_STATE_FULLY_CHARGED,
|
||||
DKP_DEVICE_STATE_UNKNOWN
|
||||
} DkpDeviceState;
|
||||
|
||||
typedef enum {
|
||||
DKP_SOURCE_TECHNOLGY_LITHIUM_ION,
|
||||
DKP_SOURCE_TECHNOLGY_LITHIUM_POLYMER,
|
||||
DKP_SOURCE_TECHNOLGY_LITHIUM_IRON_PHOSPHATE,
|
||||
DKP_SOURCE_TECHNOLGY_LEAD_ACID,
|
||||
DKP_SOURCE_TECHNOLGY_NICKEL_CADMIUM,
|
||||
DKP_SOURCE_TECHNOLGY_NICKEL_METAL_HYDRIDE,
|
||||
DKP_SOURCE_TECHNOLGY_UNKNOWN
|
||||
} DkpSourceTechnology;
|
||||
DKP_DEVICE_TECHNOLGY_LITHIUM_ION,
|
||||
DKP_DEVICE_TECHNOLGY_LITHIUM_POLYMER,
|
||||
DKP_DEVICE_TECHNOLGY_LITHIUM_IRON_PHOSPHATE,
|
||||
DKP_DEVICE_TECHNOLGY_LEAD_ACID,
|
||||
DKP_DEVICE_TECHNOLGY_NICKEL_CADMIUM,
|
||||
DKP_DEVICE_TECHNOLGY_NICKEL_METAL_HYDRIDE,
|
||||
DKP_DEVICE_TECHNOLGY_UNKNOWN
|
||||
} DkpDeviceTechnology;
|
||||
|
||||
const gchar *dkp_source_type_to_text (DkpSourceType type_enum);
|
||||
const gchar *dkp_source_state_to_text (DkpSourceState state_enum);
|
||||
const gchar *dkp_source_technology_to_text (DkpSourceTechnology technology_enum);
|
||||
DkpSourceType dkp_source_type_from_text (const gchar *type);
|
||||
DkpSourceState dkp_source_state_from_text (const gchar *state);
|
||||
DkpSourceTechnology dkp_source_technology_from_text (const gchar *technology);
|
||||
DkpSourceTechnology dkp_acpi_to_source_technology (const char *type);
|
||||
const gchar *dkp_device_type_to_text (DkpDeviceType type_enum);
|
||||
const gchar *dkp_device_state_to_text (DkpDeviceState state_enum);
|
||||
const gchar *dkp_device_technology_to_text (DkpDeviceTechnology technology_enum);
|
||||
DkpDeviceType dkp_device_type_from_text (const gchar *type);
|
||||
DkpDeviceState dkp_device_state_from_text (const gchar *state);
|
||||
DkpDeviceTechnology dkp_device_technology_from_text (const gchar *technology);
|
||||
DkpDeviceTechnology dkp_acpi_to_device_technology (const char *type);
|
||||
|
||||
G_END_DECLS
|
||||
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ dkp_history_obj_equal (const DkpHistoryObj *obj1, const DkpHistoryObj *obj2)
|
|||
gboolean
|
||||
dkp_history_obj_print (const DkpHistoryObj *obj)
|
||||
{
|
||||
g_print ("%i\t%.3f\t%s", obj->time, obj->value, dkp_source_state_to_text (obj->state));
|
||||
g_print ("%i\t%.3f\t%s", obj->time, obj->value, dkp_device_state_to_text (obj->state));
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
|
@ -116,7 +116,7 @@ dkp_history_obj_free (DkpHistoryObj *obj)
|
|||
* dkp_history_obj_create:
|
||||
**/
|
||||
DkpHistoryObj *
|
||||
dkp_history_obj_create (gdouble value, DkpSourceState state)
|
||||
dkp_history_obj_create (gdouble value, DkpDeviceState state)
|
||||
{
|
||||
DkpHistoryObj *obj;
|
||||
GTimeVal timeval;
|
||||
|
|
@ -154,7 +154,7 @@ dkp_history_obj_from_string (const gchar *text)
|
|||
obj = dkp_history_obj_new ();
|
||||
obj->time = atoi (parts[0]);
|
||||
obj->value = atof (parts[1]);
|
||||
obj->state = dkp_source_state_from_text (parts[2]);
|
||||
obj->state = dkp_device_state_from_text (parts[2]);
|
||||
out:
|
||||
g_strfreev (parts);
|
||||
return obj;
|
||||
|
|
@ -168,6 +168,6 @@ dkp_history_obj_to_string (const DkpHistoryObj *obj)
|
|||
{
|
||||
if (obj == NULL)
|
||||
return NULL;
|
||||
return g_strdup_printf ("%i\t%.3f\t%s", obj->time, obj->value, dkp_source_state_to_text (obj->state));
|
||||
return g_strdup_printf ("%i\t%.3f\t%s", obj->time, obj->value, dkp_device_state_to_text (obj->state));
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ typedef struct
|
|||
{
|
||||
guint time;
|
||||
gdouble value;
|
||||
DkpSourceState state;
|
||||
DkpDeviceState state;
|
||||
} DkpHistoryObj;
|
||||
|
||||
DkpHistoryObj *dkp_history_obj_new (void);
|
||||
|
|
@ -39,7 +39,7 @@ gboolean dkp_history_obj_free (DkpHistoryObj *obj);
|
|||
DkpHistoryObj *dkp_history_obj_copy (const DkpHistoryObj *cobj);
|
||||
gboolean dkp_history_obj_print (const DkpHistoryObj *obj);
|
||||
DkpHistoryObj *dkp_history_obj_create (gdouble value,
|
||||
DkpSourceState state);
|
||||
DkpDeviceState state);
|
||||
gboolean dkp_history_obj_equal (const DkpHistoryObj *obj1,
|
||||
const DkpHistoryObj *obj2);
|
||||
DkpHistoryObj *dkp_history_obj_from_string (const gchar *text);
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@
|
|||
static void
|
||||
dkp_object_clear_internal (DkpObject *obj)
|
||||
{
|
||||
obj->type = DKP_SOURCE_TYPE_UNKNOWN;
|
||||
obj->type = DKP_DEVICE_TYPE_UNKNOWN;
|
||||
obj->update_time = 0;
|
||||
obj->battery_energy = -1;
|
||||
obj->battery_energy_full = -1;
|
||||
|
|
@ -42,8 +42,8 @@ dkp_object_clear_internal (DkpObject *obj)
|
|||
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->battery_state = DKP_DEVICE_STATE_UNKNOWN;
|
||||
obj->battery_technology = DKP_DEVICE_TECHNOLGY_UNKNOWN;
|
||||
obj->vendor = NULL;
|
||||
obj->model = NULL;
|
||||
obj->serial = NULL;
|
||||
|
|
@ -73,7 +73,7 @@ dkp_object_collect_props (const char *key, const GValue *value, DkpObject *obj)
|
|||
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));
|
||||
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)
|
||||
|
|
@ -93,7 +93,7 @@ dkp_object_collect_props (const char *key, const GValue *value, DkpObject *obj)
|
|||
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));
|
||||
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)
|
||||
|
|
@ -103,7 +103,7 @@ dkp_object_collect_props (const char *key, const GValue *value, DkpObject *obj)
|
|||
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));
|
||||
obj->battery_state = dkp_device_state_from_text (g_value_get_string (value));
|
||||
else
|
||||
handled = FALSE;
|
||||
|
||||
|
|
@ -284,13 +284,13 @@ dkp_object_print (const DkpObject *obj)
|
|||
g_print (" serial: %s\n", obj->serial);
|
||||
g_print (" power supply: %s\n", dkp_object_bool_to_text (obj->power_supply));
|
||||
g_print (" updated: %s (%d seconds ago)\n", time_buf, (int) (time (NULL) - obj->update_time));
|
||||
g_print (" %s\n", dkp_source_type_to_text (obj->type));
|
||||
g_print (" %s\n", dkp_device_type_to_text (obj->type));
|
||||
|
||||
if (obj->type == DKP_SOURCE_TYPE_BATTERY) {
|
||||
if (obj->type == DKP_DEVICE_TYPE_BATTERY) {
|
||||
g_print (" battery\n");
|
||||
g_print (" present: %s\n", dkp_object_bool_to_text (obj->battery_is_present));
|
||||
g_print (" rechargeable: %s\n", dkp_object_bool_to_text (obj->battery_is_rechargeable));
|
||||
g_print (" state: %s\n", dkp_source_state_to_text (obj->battery_state));
|
||||
g_print (" state: %s\n", dkp_device_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);
|
||||
|
|
@ -308,17 +308,17 @@ dkp_object_print (const DkpObject *obj)
|
|||
}
|
||||
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 (" technology: %s\n", dkp_device_technology_to_text (obj->battery_technology));
|
||||
} else if (obj->type == DKP_DEVICE_TYPE_LINE_POWER) {
|
||||
g_print (" line-power\n");
|
||||
g_print (" online: %s\n", dkp_object_bool_to_text (obj->line_power_online));
|
||||
} else if (obj->type == DKP_SOURCE_TYPE_MOUSE || obj->type == DKP_SOURCE_TYPE_KEYBOARD) {
|
||||
} else if (obj->type == DKP_DEVICE_TYPE_MOUSE || obj->type == DKP_DEVICE_TYPE_KEYBOARD) {
|
||||
g_print (" present: %s\n", dkp_object_bool_to_text (obj->battery_is_present));
|
||||
g_print (" rechargeable: %s\n", dkp_object_bool_to_text (obj->battery_is_rechargeable));
|
||||
g_print (" state: %s\n", dkp_source_state_to_text (obj->battery_state));
|
||||
g_print (" state: %s\n", dkp_device_state_to_text (obj->battery_state));
|
||||
g_print (" percentage: %g%%\n", obj->battery_percentage);
|
||||
} else {
|
||||
g_print (" unknown power source type '%s'\n", dkp_source_type_to_text (obj->type));
|
||||
g_print (" unknown device type '%s'\n", dkp_device_type_to_text (obj->type));
|
||||
ret = FALSE;
|
||||
}
|
||||
return ret;
|
||||
|
|
@ -342,8 +342,8 @@ dkp_object_diff (const DkpObject *old, const DkpObject *obj)
|
|||
if (!dkp_strequal (obj->serial, old->serial))
|
||||
g_print (" serial: %s -> %s\n", old->serial, obj->serial);
|
||||
|
||||
g_print (" %s\n", dkp_source_type_to_text (obj->type));
|
||||
if (obj->type == DKP_SOURCE_TYPE_BATTERY) {
|
||||
g_print (" %s\n", dkp_device_type_to_text (obj->type));
|
||||
if (obj->type == DKP_DEVICE_TYPE_BATTERY) {
|
||||
if (old->battery_is_present != obj->battery_is_present)
|
||||
g_print (" present: %s -> %s\n",
|
||||
dkp_object_bool_to_text (old->battery_is_present),
|
||||
|
|
@ -354,8 +354,8 @@ dkp_object_diff (const DkpObject *old, const DkpObject *obj)
|
|||
dkp_object_bool_to_text (obj->battery_is_rechargeable));
|
||||
if (old->battery_state != obj->battery_state)
|
||||
g_print (" state: %s -> %s\n",
|
||||
dkp_source_state_to_text (old->battery_state),
|
||||
dkp_source_state_to_text (obj->battery_state));
|
||||
dkp_device_state_to_text (old->battery_state),
|
||||
dkp_device_state_to_text (obj->battery_state));
|
||||
if (old->battery_energy != obj->battery_energy)
|
||||
g_print (" energy: %g -> %g Wh\n",
|
||||
old->battery_energy,
|
||||
|
|
@ -403,14 +403,14 @@ dkp_object_diff (const DkpObject *old, const DkpObject *obj)
|
|||
obj->battery_capacity);
|
||||
if (old->battery_technology != obj->battery_technology)
|
||||
g_print (" technology: %s -> %s\n",
|
||||
dkp_source_technology_to_text (old->battery_technology),
|
||||
dkp_source_technology_to_text (obj->battery_technology));
|
||||
} else if (obj->type == DKP_SOURCE_TYPE_LINE_POWER) {
|
||||
dkp_device_technology_to_text (old->battery_technology),
|
||||
dkp_device_technology_to_text (obj->battery_technology));
|
||||
} else if (obj->type == DKP_DEVICE_TYPE_LINE_POWER) {
|
||||
if (old->line_power_online != obj->line_power_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));
|
||||
} else if (obj->type == DKP_SOURCE_TYPE_MOUSE || obj->type == DKP_SOURCE_TYPE_KEYBOARD) {
|
||||
} else if (obj->type == DKP_DEVICE_TYPE_MOUSE || obj->type == DKP_DEVICE_TYPE_KEYBOARD) {
|
||||
if (old->battery_is_present != obj->battery_is_present)
|
||||
g_print (" present: %s -> %s\n",
|
||||
dkp_object_bool_to_text (old->battery_is_present),
|
||||
|
|
@ -421,14 +421,14 @@ dkp_object_diff (const DkpObject *old, const DkpObject *obj)
|
|||
dkp_object_bool_to_text (obj->battery_is_rechargeable));
|
||||
if (old->battery_state != obj->battery_state)
|
||||
g_print (" state: %s -> %s\n",
|
||||
dkp_source_state_to_text (old->battery_state),
|
||||
dkp_source_state_to_text (obj->battery_state));
|
||||
dkp_device_state_to_text (old->battery_state),
|
||||
dkp_device_state_to_text (obj->battery_state));
|
||||
if (old->battery_percentage != obj->battery_percentage)
|
||||
g_print (" percentage: %g%% -> %g%%\n",
|
||||
old->battery_percentage,
|
||||
obj->battery_percentage);
|
||||
} else {
|
||||
g_print (" unknown power source type '%s'\n", dkp_source_type_to_text (obj->type));
|
||||
g_print (" unknown device type '%s'\n", dkp_device_type_to_text (obj->type));
|
||||
ret = FALSE;
|
||||
}
|
||||
return ret;
|
||||
|
|
@ -499,7 +499,7 @@ dkp_object_get_id (DkpObject *obj)
|
|||
return id;
|
||||
|
||||
/* only valid for batteries */
|
||||
if (obj->type != DKP_SOURCE_TYPE_BATTERY)
|
||||
if (obj->type != DKP_DEVICE_TYPE_BATTERY)
|
||||
return id;
|
||||
|
||||
/* we don't have an ID if we are not present */
|
||||
|
|
|
|||
|
|
@ -36,9 +36,9 @@ typedef struct {
|
|||
gboolean line_power_online;
|
||||
gboolean battery_is_present;
|
||||
gboolean battery_is_rechargeable;
|
||||
DkpSourceType type;
|
||||
DkpSourceState battery_state;
|
||||
DkpSourceTechnology battery_technology;
|
||||
DkpDeviceType type;
|
||||
DkpDeviceState battery_state;
|
||||
DkpDeviceTechnology battery_technology;
|
||||
gdouble battery_capacity;
|
||||
gdouble battery_energy;
|
||||
gdouble battery_energy_empty;
|
||||
|
|
|
|||
|
|
@ -148,12 +148,12 @@ dkp_csr_coldplug (DkpDevice *device)
|
|||
/* get the type */
|
||||
type = devkit_device_get_property (d, "ID_BATTERY_TYPE");
|
||||
if (strcmp (type, "mouse") == 0)
|
||||
obj->type = DKP_SOURCE_TYPE_MOUSE;
|
||||
obj->type = DKP_DEVICE_TYPE_MOUSE;
|
||||
if (strcmp (type, "keyboard") == 0)
|
||||
obj->type = DKP_SOURCE_TYPE_KEYBOARD;
|
||||
obj->type = DKP_DEVICE_TYPE_KEYBOARD;
|
||||
|
||||
/* nothing known */
|
||||
if (obj->type == DKP_SOURCE_TYPE_UNKNOWN) {
|
||||
if (obj->type == DKP_DEVICE_TYPE_UNKNOWN) {
|
||||
dkp_warning ("not a mouse or keyboard");
|
||||
ret = FALSE;
|
||||
goto out;
|
||||
|
|
@ -180,7 +180,7 @@ dkp_csr_coldplug (DkpDevice *device)
|
|||
obj->power_supply = FALSE;
|
||||
obj->battery_is_present = TRUE;
|
||||
obj->battery_is_rechargeable = TRUE;
|
||||
obj->battery_state = DKP_SOURCE_STATE_DISCHARGING;
|
||||
obj->battery_state = DKP_DEVICE_STATE_DISCHARGING;
|
||||
|
||||
/* try to get the usb device */
|
||||
csr->priv->device = dkp_csr_find_device (csr);
|
||||
|
|
|
|||
|
|
@ -162,7 +162,7 @@ dkp_device_get_property (GObject *object, guint prop_id, GValue *value, GParamSp
|
|||
g_value_set_uint64 (value, obj->update_time);
|
||||
break;
|
||||
case PROP_TYPE:
|
||||
g_value_set_string (value, dkp_source_type_to_text (obj->type));
|
||||
g_value_set_string (value, dkp_device_type_to_text (obj->type));
|
||||
break;
|
||||
case PROP_POWER_SUPPLY:
|
||||
g_value_set_boolean (value, obj->power_supply);
|
||||
|
|
@ -177,7 +177,7 @@ dkp_device_get_property (GObject *object, guint prop_id, GValue *value, GParamSp
|
|||
g_value_set_boolean (value, obj->battery_is_rechargeable);
|
||||
break;
|
||||
case PROP_BATTERY_STATE:
|
||||
g_value_set_string (value, dkp_source_state_to_text (obj->battery_state));
|
||||
g_value_set_string (value, dkp_device_state_to_text (obj->battery_state));
|
||||
break;
|
||||
case PROP_BATTERY_CAPACITY:
|
||||
g_value_set_double (value, obj->battery_capacity);
|
||||
|
|
@ -207,7 +207,7 @@ dkp_device_get_property (GObject *object, guint prop_id, GValue *value, GParamSp
|
|||
g_value_set_double (value, obj->battery_percentage);
|
||||
break;
|
||||
case PROP_BATTERY_TECHNOLOGY:
|
||||
g_value_set_string (value, dkp_source_technology_to_text (obj->battery_technology));
|
||||
g_value_set_string (value, dkp_device_technology_to_text (obj->battery_technology));
|
||||
break;
|
||||
|
||||
default:
|
||||
|
|
@ -327,7 +327,7 @@ dkp_device_get_statistics (DkpDevice *device, const gchar *type, guint timespan,
|
|||
value = g_new0 (GValue, 1);
|
||||
g_value_init (value, DKP_DBUS_STRUCT_UINT_DOUBLE_STRING);
|
||||
g_value_take_boxed (value, dbus_g_type_specialized_construct (DKP_DBUS_STRUCT_UINT_DOUBLE_STRING));
|
||||
dbus_g_type_struct_set (value, 0, obj->time, 1, obj->value, 2, dkp_source_state_to_text (obj->state), -1);
|
||||
dbus_g_type_struct_set (value, 0, obj->time, 1, obj->value, 2, dkp_device_state_to_text (obj->state), -1);
|
||||
g_ptr_array_add (complex, g_value_get_boxed (value));
|
||||
g_free (value);
|
||||
}
|
||||
|
|
@ -457,7 +457,7 @@ dkp_device_compute_object_path (DkpDevice *device)
|
|||
const gchar *type;
|
||||
guint i;
|
||||
|
||||
type = dkp_source_type_to_text (device->priv->obj->type);
|
||||
type = dkp_device_type_to_text (device->priv->obj->type);
|
||||
native_path = device->priv->obj->native_path;
|
||||
basename = g_path_get_basename (native_path);
|
||||
id = g_strjoin ("_", type, basename, NULL);
|
||||
|
|
@ -486,7 +486,7 @@ dkp_device_register_device (DkpDevice *device)
|
|||
gboolean ret = TRUE;
|
||||
|
||||
device->priv->object_path = dkp_device_compute_object_path (device);
|
||||
dkp_warning ("object path = %s", device->priv->object_path);
|
||||
dkp_debug ("object path = %s", device->priv->object_path);
|
||||
dbus_g_connection_register_g_object (device->priv->system_bus_connection,
|
||||
device->priv->object_path, G_OBJECT (device));
|
||||
device->priv->system_bus_proxy = dbus_g_proxy_new_for_name (device->priv->system_bus_connection,
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@ struct DkpHistoryPrivate
|
|||
gchar *id;
|
||||
gdouble rate_last;
|
||||
gdouble percentage_last;
|
||||
DkpSourceState state;
|
||||
DkpDeviceState state;
|
||||
GPtrArray *data_rate;
|
||||
GPtrArray *data_charge;
|
||||
guint save_id;
|
||||
|
|
@ -236,7 +236,7 @@ dkp_history_is_low_power (DkpHistory *history)
|
|||
const DkpHistoryObj *obj;
|
||||
|
||||
/* current status is always up to date */
|
||||
if (history->priv->state != DKP_SOURCE_STATE_DISCHARGING)
|
||||
if (history->priv->state != DKP_DEVICE_STATE_DISCHARGING)
|
||||
return FALSE;
|
||||
|
||||
/* have we got any data? */
|
||||
|
|
@ -246,7 +246,7 @@ dkp_history_is_low_power (DkpHistory *history)
|
|||
|
||||
/* get the last saved charge object */
|
||||
obj = (const DkpHistoryObj *) g_ptr_array_index (history->priv->data_charge, length-1);
|
||||
if (obj->state != DKP_SOURCE_STATE_DISCHARGING)
|
||||
if (obj->state != DKP_DEVICE_STATE_DISCHARGING)
|
||||
return FALSE;
|
||||
|
||||
/* high enough */
|
||||
|
|
@ -392,7 +392,7 @@ dkp_history_set_id (DkpHistory *history, const gchar *id)
|
|||
* dkp_history_set_state:
|
||||
**/
|
||||
gboolean
|
||||
dkp_history_set_state (DkpHistory *history, DkpSourceState state)
|
||||
dkp_history_set_state (DkpHistory *history, DkpDeviceState state)
|
||||
{
|
||||
g_return_val_if_fail (DKP_IS_HISTORY (history), FALSE);
|
||||
|
||||
|
|
@ -414,7 +414,7 @@ dkp_history_set_charge_data (DkpHistory *history, gdouble percentage)
|
|||
|
||||
if (history->priv->id == NULL)
|
||||
return FALSE;
|
||||
if (history->priv->state == DKP_SOURCE_STATE_UNKNOWN)
|
||||
if (history->priv->state == DKP_DEVICE_STATE_UNKNOWN)
|
||||
return FALSE;
|
||||
if (history->priv->percentage_last == percentage)
|
||||
return FALSE;
|
||||
|
|
@ -442,7 +442,7 @@ dkp_history_set_rate_data (DkpHistory *history, gdouble rate)
|
|||
|
||||
if (history->priv->id == NULL)
|
||||
return FALSE;
|
||||
if (history->priv->state == DKP_SOURCE_STATE_UNKNOWN)
|
||||
if (history->priv->state == DKP_DEVICE_STATE_UNKNOWN)
|
||||
return FALSE;
|
||||
if (history->priv->rate_last == rate)
|
||||
return FALSE;
|
||||
|
|
@ -481,7 +481,7 @@ dkp_history_init (DkpHistory *history)
|
|||
history->priv->id = NULL;
|
||||
history->priv->rate_last = 0;
|
||||
history->priv->percentage_last = 0;
|
||||
history->priv->state = DKP_SOURCE_STATE_UNKNOWN;
|
||||
history->priv->state = DKP_DEVICE_STATE_UNKNOWN;
|
||||
history->priv->data_rate = g_ptr_array_new ();
|
||||
history->priv->data_charge = g_ptr_array_new ();
|
||||
history->priv->save_id = 0;
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ GPtrArray *dkp_history_get_rate_data (DkpHistory *history,
|
|||
gboolean dkp_history_set_id (DkpHistory *history,
|
||||
const gchar *id);
|
||||
gboolean dkp_history_set_state (DkpHistory *history,
|
||||
DkpSourceState state);
|
||||
DkpDeviceState state);
|
||||
gboolean dkp_history_set_charge_data (DkpHistory *history,
|
||||
gdouble percentage);
|
||||
gboolean dkp_history_set_rate_data (DkpHistory *history,
|
||||
|
|
|
|||
|
|
@ -82,7 +82,7 @@ static void
|
|||
dkp_supply_reset_values (DkpSupply *supply)
|
||||
{
|
||||
gchar *native_path;
|
||||
DkpSourceType type;
|
||||
DkpDeviceType type;
|
||||
DkpDevice *device = DKP_DEVICE (supply);
|
||||
DkpObject *obj = dkp_device_get_obj (device);
|
||||
|
||||
|
|
@ -112,12 +112,12 @@ dkp_supply_get_on_battery (DkpDevice *device, gboolean *on_battery)
|
|||
g_return_val_if_fail (DKP_IS_SUPPLY (supply), FALSE);
|
||||
g_return_val_if_fail (on_battery != NULL, FALSE);
|
||||
|
||||
if (obj->type != DKP_SOURCE_TYPE_BATTERY)
|
||||
if (obj->type != DKP_DEVICE_TYPE_BATTERY)
|
||||
return FALSE;
|
||||
if (!obj->battery_is_present)
|
||||
return FALSE;
|
||||
|
||||
*on_battery = (obj->battery_state == DKP_SOURCE_STATE_DISCHARGING);
|
||||
*on_battery = (obj->battery_state == DKP_DEVICE_STATE_DISCHARGING);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
|
@ -197,7 +197,7 @@ dkp_supply_refresh_battery (DkpSupply *supply)
|
|||
{
|
||||
gchar *status = NULL;
|
||||
gboolean ret = TRUE;
|
||||
DkpSourceState battery_state;
|
||||
DkpDeviceState battery_state;
|
||||
DkpDevice *device = DKP_DEVICE (supply);
|
||||
DkpObject *obj = dkp_device_get_obj (device);
|
||||
|
||||
|
|
@ -205,7 +205,7 @@ dkp_supply_refresh_battery (DkpSupply *supply)
|
|||
obj->battery_is_present = sysfs_get_bool (obj->native_path, "present");
|
||||
if (!obj->battery_is_present) {
|
||||
dkp_supply_reset_values (supply);
|
||||
obj->type = DKP_SOURCE_TYPE_BATTERY;
|
||||
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_source_technology (technology_native);
|
||||
obj->battery_technology = dkp_acpi_to_device_technology (technology_native);
|
||||
g_free (technology_native);
|
||||
|
||||
obj->vendor = g_strstrip (sysfs_get_string (obj->native_path, "manufacturer"));
|
||||
|
|
@ -251,16 +251,16 @@ dkp_supply_refresh_battery (DkpSupply *supply)
|
|||
|
||||
status = g_strstrip (sysfs_get_string (obj->native_path, "status"));
|
||||
if (strcasecmp (status, "charging") == 0)
|
||||
battery_state = DKP_SOURCE_STATE_CHARGING;
|
||||
battery_state = DKP_DEVICE_STATE_CHARGING;
|
||||
else if (strcasecmp (status, "discharging") == 0)
|
||||
battery_state = DKP_SOURCE_STATE_DISCHARGING;
|
||||
battery_state = DKP_DEVICE_STATE_DISCHARGING;
|
||||
else if (strcasecmp (status, "full") == 0)
|
||||
battery_state = DKP_SOURCE_STATE_FULLY_CHARGED;
|
||||
battery_state = DKP_DEVICE_STATE_FULLY_CHARGED;
|
||||
else if (strcasecmp (status, "empty") == 0)
|
||||
battery_state = DKP_SOURCE_STATE_EMPTY;
|
||||
battery_state = DKP_DEVICE_STATE_EMPTY;
|
||||
else {
|
||||
dkp_warning ("unknown status string: %s", status);
|
||||
battery_state = DKP_SOURCE_STATE_UNKNOWN;
|
||||
battery_state = DKP_DEVICE_STATE_UNKNOWN;
|
||||
}
|
||||
|
||||
/* get the currect charge */
|
||||
|
|
@ -293,7 +293,7 @@ dkp_supply_refresh_battery (DkpSupply *supply)
|
|||
}
|
||||
|
||||
/* charging has a negative rate */
|
||||
if (obj->battery_energy_rate > 0 && battery_state == DKP_SOURCE_STATE_CHARGING)
|
||||
if (obj->battery_energy_rate > 0 && battery_state == DKP_DEVICE_STATE_CHARGING)
|
||||
obj->battery_energy_rate *= -1.0;
|
||||
|
||||
/* get a precise percentage */
|
||||
|
|
@ -307,9 +307,9 @@ dkp_supply_refresh_battery (DkpSupply *supply)
|
|||
obj->battery_time_to_empty = -1;
|
||||
obj->battery_time_to_full = -1;
|
||||
if (obj->battery_energy_rate > 0) {
|
||||
if (battery_state == DKP_SOURCE_STATE_DISCHARGING) {
|
||||
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_SOURCE_STATE_CHARGING) {
|
||||
} 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);
|
||||
}
|
||||
}
|
||||
|
|
@ -403,10 +403,10 @@ dkp_supply_coldplug (DkpDevice *device)
|
|||
dkp_error ("could not get native path");
|
||||
|
||||
if (sysfs_file_exists (native_path, "online")) {
|
||||
obj->type = DKP_SOURCE_TYPE_LINE_POWER;
|
||||
obj->type = DKP_DEVICE_TYPE_LINE_POWER;
|
||||
} else {
|
||||
/* this is correct, UPS and CSR are not in the kernel */
|
||||
obj->type = DKP_SOURCE_TYPE_BATTERY;
|
||||
obj->type = DKP_DEVICE_TYPE_BATTERY;
|
||||
}
|
||||
|
||||
/* get the id so we can load the old history */
|
||||
|
|
@ -440,16 +440,16 @@ dkp_supply_refresh (DkpDevice *device)
|
|||
obj->update_time = time.tv_sec;
|
||||
|
||||
switch (obj->type) {
|
||||
case DKP_SOURCE_TYPE_LINE_POWER:
|
||||
case DKP_DEVICE_TYPE_LINE_POWER:
|
||||
ret = dkp_supply_refresh_line_power (supply);
|
||||
break;
|
||||
case DKP_SOURCE_TYPE_BATTERY:
|
||||
case DKP_DEVICE_TYPE_BATTERY:
|
||||
ret = dkp_supply_refresh_battery (supply);
|
||||
/* 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_SOURCE_STATE_CHARGING ||
|
||||
obj->battery_state == DKP_SOURCE_STATE_DISCHARGING)
|
||||
if (obj->battery_state == DKP_DEVICE_STATE_CHARGING ||
|
||||
obj->battery_state == DKP_DEVICE_STATE_DISCHARGING)
|
||||
supply->priv->poll_timer_id =
|
||||
g_timeout_add_seconds (DKP_SUPPLY_REFRESH_TIMEOUT,
|
||||
(GSourceFunc) dkp_supply_poll_battery, supply);
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ struct DkpClientDevicePrivate
|
|||
gchar *object_path;
|
||||
DkpObject *obj;
|
||||
DBusGConnection *bus;
|
||||
DBusGProxy *proxy_source;
|
||||
DBusGProxy *proxy_device;
|
||||
DBusGProxy *proxy_props;
|
||||
};
|
||||
|
||||
|
|
@ -118,7 +118,7 @@ dkp_client_device_set_object_path (DkpClientDevice *device, const gchar *object_
|
|||
{
|
||||
GError *error = NULL;
|
||||
gboolean ret = FALSE;
|
||||
DBusGProxy *proxy_source;
|
||||
DBusGProxy *proxy_device;
|
||||
DBusGProxy *proxy_props;
|
||||
|
||||
g_return_val_if_fail (DKP_IS_CLIENT_DEVICE (device), FALSE);
|
||||
|
|
@ -145,21 +145,21 @@ dkp_client_device_set_object_path (DkpClientDevice *device, const gchar *object_
|
|||
}
|
||||
|
||||
/* connect to the correct path for all the other methods */
|
||||
proxy_source = dbus_g_proxy_new_for_name (device->priv->bus, "org.freedesktop.DeviceKit.Power",
|
||||
proxy_device = dbus_g_proxy_new_for_name (device->priv->bus, "org.freedesktop.DeviceKit.Power",
|
||||
object_path, "org.freedesktop.DeviceKit.Power.Device");
|
||||
if (proxy_source == NULL) {
|
||||
if (proxy_device == NULL) {
|
||||
dkp_warning ("Couldn't connect to proxy");
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* listen to Changed */
|
||||
dbus_g_proxy_add_signal (proxy_source, "Changed", G_TYPE_INVALID);
|
||||
dbus_g_proxy_connect_signal (proxy_source, "Changed",
|
||||
dbus_g_proxy_add_signal (proxy_device, "Changed", G_TYPE_INVALID);
|
||||
dbus_g_proxy_connect_signal (proxy_device, "Changed",
|
||||
G_CALLBACK (dkp_client_device_changed_cb), device, NULL);
|
||||
|
||||
/* yay */
|
||||
dkp_debug ("using object_path: %s", object_path);
|
||||
device->priv->proxy_source = proxy_source;
|
||||
device->priv->proxy_device = proxy_device;
|
||||
device->priv->proxy_props = proxy_props;
|
||||
device->priv->object_path = g_strdup (object_path);
|
||||
|
||||
|
|
@ -218,10 +218,10 @@ dkp_client_device_refresh (DkpClientDevice *device)
|
|||
gboolean ret;
|
||||
|
||||
g_return_val_if_fail (DKP_IS_CLIENT_DEVICE (device), FALSE);
|
||||
g_return_val_if_fail (device->priv->proxy_source != NULL, FALSE);
|
||||
g_return_val_if_fail (device->priv->proxy_device != NULL, FALSE);
|
||||
|
||||
/* just refresh the device */
|
||||
ret = dbus_g_proxy_call (device->priv->proxy_source, "Refresh", &error,
|
||||
ret = dbus_g_proxy_call (device->priv->proxy_device, "Refresh", &error,
|
||||
G_TYPE_INVALID, G_TYPE_INVALID);
|
||||
if (!ret) {
|
||||
dkp_debug ("Refresh() on %s failed: %s", device->priv->object_path, error->message);
|
||||
|
|
@ -260,7 +260,7 @@ dkp_client_device_get_statistics (const DkpClientDevice *device, const gchar *ty
|
|||
G_TYPE_INVALID));
|
||||
|
||||
/* get compound data */
|
||||
ret = dbus_g_proxy_call (device->priv->proxy_source, "GetStatistics", &error,
|
||||
ret = dbus_g_proxy_call (device->priv->proxy_device, "GetStatistics", &error,
|
||||
G_TYPE_STRING, type,
|
||||
G_TYPE_UINT, timespec,
|
||||
G_TYPE_INVALID,
|
||||
|
|
@ -292,7 +292,7 @@ dkp_client_device_get_statistics (const DkpClientDevice *device, const gchar *ty
|
|||
g_value_unset (gv);
|
||||
/* 2 */
|
||||
gv = g_value_array_get_nth (gva, 2);
|
||||
obj->state = dkp_source_state_from_text (g_value_get_string (gv));
|
||||
obj->state = dkp_device_state_from_text (g_value_get_string (gv));
|
||||
g_value_unset (gv);
|
||||
g_ptr_array_add (array, obj);
|
||||
g_value_array_free (gva);
|
||||
|
|
@ -340,7 +340,7 @@ dkp_client_device_init (DkpClientDevice *device)
|
|||
{
|
||||
device->priv = DKP_CLIENT_DEVICE_GET_PRIVATE (device);
|
||||
device->priv->object_path = NULL;
|
||||
device->priv->proxy_source = NULL;
|
||||
device->priv->proxy_device = NULL;
|
||||
device->priv->proxy_props = NULL;
|
||||
device->priv->obj = dkp_object_new ();
|
||||
}
|
||||
|
|
@ -360,8 +360,8 @@ dkp_client_device_finalize (GObject *object)
|
|||
|
||||
g_free (device->priv->object_path);
|
||||
dkp_object_free (device->priv->obj);
|
||||
if (device->priv->proxy_source != NULL)
|
||||
g_object_unref (device->priv->proxy_source);
|
||||
if (device->priv->proxy_device != NULL)
|
||||
g_object_unref (device->priv->proxy_device);
|
||||
if (device->priv->proxy_props != NULL)
|
||||
g_object_unref (device->priv->proxy_props);
|
||||
dbus_g_connection_unref (device->priv->bus);
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue