of course, the right thing to do is make a static lib to avoid playing with ../src/ type paths

1 files changed, 361 insertions, 0 deletions

diff --git a/libdevkit-power/dkp-object.c b/libdevkit-power/dkp-object.c
new file mode 100644
index 0000000..c76e0f6
--- /dev/null
+++ b/libdevkit-power/dkp-object.c
@@ -0,0 +1,361 @@
+/* -*- 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_strzero:
+ * @text: The text to check
+ *
+ * This function is a much safer way of doing "if (strlen (text) == 0))"
+ * as it does not rely on text being NULL terminated. It's also much
+ * quicker as it only checks the first byte rather than scanning the whole
+ * string just to verify it's not zero length.
+ *
+ * Return value: %TRUE if the string was converted correctly
+ **/
+static gboolean
+dkp_strzero (const gchar *text)
+{
+	if (text == NULL) {
+		return TRUE;
+	}
+	if (text[0] == '\0') {
+		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);
+	if (!dkp_strzero (obj->vendor))
+		g_print ("  vendor:               %s\n", obj->vendor);
+	if (!dkp_strzero (obj->model))
+		g_print ("  model:                %s\n", obj->model);
+	if (!dkp_strzero (obj->serial))
+		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;
+}
+