1 files changed, 608 insertions, 0 deletions
diff --git a/battstat/battstat-hal.c b/battstat/battstat-hal.c
new file mode 100644
index 00000000..af9428db
--- /dev/null
+++ b/battstat/battstat-hal.c
@@ -0,0 +1,608 @@
+/*
+ * Copyright (C) 2005 by Ryan Lortie <[email protected]>
+ *
+ * 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., 59 Temple Street #330, Boston, MA 02111-1307, USA.
+ *
+ * $Id$
+ */
+
+#include <config.h>
+
+#ifdef HAVE_HAL
+
+#include <dbus/dbus-glib-lowlevel.h>
+#include <libhal.h>
+#include <string.h>
+#include <math.h>
+
+#include "battstat-hal.h"
+
+static LibHalContext *battstat_hal_ctx;
+static GSList *batteries;
+static GSList *adaptors;
+static void (*status_updated_callback) (void);
+
+struct battery_status
+{
+ int present;
+ int current_level, design_level, full_level;
+ int remaining_time;
+ int charging, discharging;
+ int rate;
+};
+
+struct battery_info
+{
+ char *udi; /* must be first member */
+ struct battery_status status;
+};
+
+struct adaptor_info
+{
+ char *udi; /* must be first member */
+ int present;
+};
+
+static gboolean
+battery_update_property( LibHalContext *ctx, struct battery_info *battery,
+ const char *key )
+{
+ DBusError error;
+ gboolean ret;
+
+ ret = TRUE;
+ dbus_error_init( &error );
+
+ if( !strcmp( key, "battery.present" ) )
+ battery->status.present =
+ libhal_device_get_property_bool( ctx, battery->udi, key, &error );
+
+ if( !strcmp( key, "battery.charge_level.current" ) )
+ battery->status.current_level =
+ libhal_device_get_property_int( ctx, battery->udi, key, &error );
+
+ if( !strcmp( key, "battery.charge_level.rate" ) )
+ battery->status.rate =
+ libhal_device_get_property_int( ctx, battery->udi, key, &error );
+
+ else if( !strcmp( key, "battery.charge_level.design" ) )
+ battery->status.design_level =
+ libhal_device_get_property_int( ctx, battery->udi, key, &error );
+
+ else if( !strcmp( key, "battery.charge_level.last_full" ) )
+ battery->status.full_level =
+ libhal_device_get_property_int( ctx, battery->udi, key, &error );
+
+ else if( !strcmp( key, "battery.remaining_time" ) )
+ battery->status.remaining_time =
+ libhal_device_get_property_int( ctx, battery->udi, key, &error );
+
+ else if( !strcmp( key, "battery.rechargeable.is_charging" ) )
+ battery->status.charging =
+ libhal_device_get_property_bool( ctx, battery->udi, key, &error );
+
+ else if( !strcmp( key, "battery.rechargeable.is_discharging" ) )
+ battery->status.discharging =
+ libhal_device_get_property_bool( ctx, battery->udi, key, &error );
+
+ else
+ ret = FALSE;
+
+ dbus_error_free( &error );
+
+ return ret;
+}
+
+static gboolean
+adaptor_update_property( LibHalContext *ctx, struct adaptor_info *adaptor,
+ const char *key )
+{
+ DBusError error;
+ gboolean ret;
+
+ ret = TRUE;
+ dbus_error_init( &error );
+
+ if( !strcmp( key, "ac_adapter.present" ) )
+ adaptor->present =
+ libhal_device_get_property_bool( ctx, adaptor->udi, key, &error );
+ else
+ ret = FALSE;
+
+ dbus_error_free( &error );
+
+ return ret;
+}
+
+static GSList *
+find_link_by_udi( GSList *list, const char *udi )
+{
+ GSList *link;
+
+ for( link = list; link; link = g_slist_next( link ) )
+ {
+ /* this might be an adaptor! this is OK as long as 'udi' is the first
+ * member of both structures.
+ */
+ struct battery_info *battery = link->data;
+
+ if( !strcmp( udi, battery->udi ) )
+ return link;
+ }
+
+ return NULL;
+}
+
+static void *
+find_device_by_udi( GSList *list, const char *udi )
+{
+ GSList *link;
+
+ link = find_link_by_udi( list, udi );
+
+ if( link )
+ return link->data;
+ else
+ return NULL;
+}
+
+static gboolean status_update_scheduled;
+
+static gboolean
+update_status_idle (gpointer junk)
+{
+ if (status_updated_callback)
+ status_updated_callback ();
+
+ return status_update_scheduled = FALSE;
+}
+
+static void
+schedule_status_callback (void)
+{
+ if (status_update_scheduled)
+ return;
+
+ status_update_scheduled = TRUE;
+ g_idle_add (update_status_idle, NULL);
+}
+
+static void
+property_callback( LibHalContext *ctx, const char *udi, const char *key,
+ dbus_bool_t is_removed, dbus_bool_t is_added )
+{
+ struct battery_info *battery;
+ struct adaptor_info *adaptor;
+ gboolean changed;
+
+ /* It is safe to do nothing since the device will have been marked as
+ * not present and the old information will be ignored.
+ */
+ if( is_removed )
+ return;
+
+ changed = FALSE;
+
+ if( (battery = find_device_by_udi( batteries, udi )) )
+ changed |= battery_update_property( ctx, battery, key );
+
+ if( (adaptor = find_device_by_udi( adaptors, udi )) )
+ changed |= adaptor_update_property( ctx, adaptor, key );
+
+ if (changed && status_updated_callback)
+ schedule_status_callback ();
+}
+
+static void
+add_to_list( LibHalContext *ctx, GSList **list, const char *udi, int size )
+{
+ struct battery_info *battery = g_malloc0( size );
+ LibHalPropertySetIterator iter;
+ LibHalPropertySet *properties;
+ DBusError error;
+
+ /* this might be an adaptor! this is OK as long as 'udi' is the first
+ * member of both structures.
+ */
+ battery->udi = g_strdup( udi );
+ *list = g_slist_append( *list, battery );
+
+ dbus_error_init( &error );
+
+ libhal_device_add_property_watch( ctx, udi, &error );
+
+ properties = libhal_device_get_all_properties( ctx, udi, &error );
+
+ for( libhal_psi_init( &iter, properties );
+ libhal_psi_has_more( &iter );
+ libhal_psi_next( &iter ) )
+ {
+ const char *key = libhal_psi_get_key( &iter );
+ property_callback( ctx, udi, key, FALSE, FALSE );
+ }
+ 
+ libhal_free_property_set( properties );
+ dbus_error_free( &error );
+}
+
+static void
+free_list_data( void *data )
+{
+ /* this might be an adaptor! this is OK as long as 'udi' is the first
+ * member of both structures.
+ */
+ struct battery_info *battery = data;
+
+ g_free( battery->udi );
+ g_free( battery );
+}
+
+static GSList *
+remove_from_list( LibHalContext *ctx, GSList *list, const char *udi )
+{
+ GSList *link = find_link_by_udi( list, udi );
+
+ if( link )
+ {
+ DBusError error;
+
+ dbus_error_init( &error );
+ libhal_device_remove_property_watch( ctx, udi, &error );
+ dbus_error_free( &error );
+
+ free_list_data( link->data );
+ list = g_slist_delete_link( list, link );
+ }
+
+ return list;
+}
+
+static GSList *
+free_entire_list( GSList *list )
+{
+ GSList *item;
+ 
+ for( item = list; item; item = g_slist_next( item ) )
+ free_list_data( item->data );
+
+ g_slist_free( list );
+
+ return NULL;
+}
+
+static void
+device_added_callback( LibHalContext *ctx, const char *udi )
+{
+ if( libhal_device_property_exists( ctx, udi, "battery", NULL ) )
+ {
+ char *type = libhal_device_get_property_string( ctx, udi,
+ "battery.type",
+ NULL );
+
+ if( type )
+ {
+ /* We only track 'primary' batteries (ie: to avoid monitoring
+ * batteries in cordless mice or UPSes etc.)
+ */
+ if( !strcmp( type, "primary" ) )
+ add_to_list( ctx, &batteries, udi, sizeof (struct battery_info) );
+
+ libhal_free_string( type );
+ }
+ }
+
+ if( libhal_device_property_exists( ctx, udi, "ac_adapter", NULL ) )
+ add_to_list( ctx, &adaptors, udi, sizeof (struct adaptor_info) );
+}
+
+static void
+device_removed_callback( LibHalContext *ctx, const char *udi )
+{
+ batteries = remove_from_list( ctx, batteries, udi );
+ adaptors = remove_from_list( ctx, adaptors, udi );
+}
+
+/* ---- public functions ---- */
+
+char *
+battstat_hal_initialise (void (*callback) (void))
+{
+ DBusConnection *connection;
+ LibHalContext *ctx;
+ DBusError error;
+ char *error_str;
+ char **devices;
+ int i, num;
+
+ status_updated_callback = callback;
+
+ if( battstat_hal_ctx != NULL )
+ return g_strdup( "Already initialised!" );
+
+ dbus_error_init( &error );
+
+ if( (connection = dbus_bus_get( DBUS_BUS_SYSTEM, &error )) == NULL )
+ goto error_out;
+
+ dbus_connection_setup_with_g_main( connection, g_main_context_default() );
+
+ if( (ctx = libhal_ctx_new()) == NULL )
+ {
+ dbus_set_error( &error, _("HAL error"), _("Could not create libhal_ctx") );
+ goto error_out;
+ }
+
+ libhal_ctx_set_device_property_modified( ctx, property_callback );
+ libhal_ctx_set_device_added( ctx, device_added_callback );
+ libhal_ctx_set_device_removed( ctx, device_removed_callback );
+ libhal_ctx_set_dbus_connection( ctx, connection );
+
+ if( libhal_ctx_init( ctx, &error ) == 0 )
+ goto error_freectx;
+ 
+ devices = libhal_find_device_by_capability( ctx, "battery", &num, &error );
+
+ if( devices == NULL )
+ goto error_shutdownctx;
+
+ /* FIXME: for now, if 0 battery devices are present on first scan, then fail.
+ * This allows fallover to the legacy (ACPI, APM, etc) backends if the
+ * installed version of HAL doesn't know about batteries. This check should
+ * be removed at some point in the future (maybe circa MATE 2.13..).
+ */
+ if( num == 0 )
+ {
+ dbus_free_string_array( devices );
+ dbus_set_error( &error, _("HAL error"), _("No batteries found") );
+ goto error_shutdownctx;
+ }
+
+ for( i = 0; i < num; i++ )
+ {
+ char *type = libhal_device_get_property_string( ctx, devices[i],
+ "battery.type",
+ &error );
+
+ if( type )
+ {
+ /* We only track 'primary' batteries (ie: to avoid monitoring
+ * batteries in cordless mice or UPSes etc.)
+ */
+ if( !strcmp( type, "primary" ) )
+ add_to_list( ctx, &batteries, devices[i],
+ sizeof (struct battery_info) );
+
+ libhal_free_string( type );
+ }
+ }
+ dbus_free_string_array( devices );
+
+ devices = libhal_find_device_by_capability( ctx, "ac_adapter", &num, &error );
+
+ if( devices == NULL )
+ {
+ batteries = free_entire_list( batteries );
+ goto error_shutdownctx;
+ }
+
+ for( i = 0; i < num; i++ )
+ add_to_list( ctx, &adaptors, devices[i], sizeof (struct adaptor_info) );
+ dbus_free_string_array( devices );
+
+ dbus_error_free( &error );
+
+ battstat_hal_ctx = ctx;
+
+ return NULL;
+
+error_shutdownctx:
+ libhal_ctx_shutdown( ctx, NULL );
+
+error_freectx:
+ libhal_ctx_free( ctx );
+
+error_out:
+ error_str = g_strdup_printf( _("Unable to initialise HAL: %s: %s"),
+ error.name, error.message );
+ dbus_error_free( &error );
+ return error_str;
+}
+
+void
+battstat_hal_cleanup( void )
+{
+ if( battstat_hal_ctx == NULL )
+ return;
+
+ libhal_ctx_free( battstat_hal_ctx );
+ batteries = free_entire_list( batteries );
+ adaptors = free_entire_list( adaptors );
+}
+
+#include "battstat.h"
+
+/* This function currently exists to allow the multiple batteries supported
+ * by the HAL backend to appear as a single composite battery device (since
+ * at the current time this is all that battstat supports).
+ *
+ * This entire function is filled with logic to make multiple batteries
+ * appear as one "composite" battery. Comments included as appropriate.
+ *
+ * For more information about some of the assumptions made in the following
+ * code please see the following mailing list post and the resulting thread:
+ *
+ * http://lists.freedesktop.org/archives/hal/2005-July/002841.html
+ */
+void
+battstat_hal_get_battery_info( BatteryStatus *status )
+{
+ /* The calculation to get overall percentage power remaining is as follows:
+ *
+ * Sum( Current charges ) / Sum( Full Capacities )
+ *
+ * We can't just take an average of all of the percentages since this
+ * doesn't deal with the case that one battery might have a larger
+ * capacity than the other.
+ *
+ * In order to do this calculation, we need to keep a running total of
+ * current charge and full capacities.
+ */
+ int current_charge_total = 0, full_capacity_total = 0;
+
+ /* Record the time remaining as reported by HAL. This is used in the event
+ * that the system has exactly one battery (since, then, the HAL is capable
+ * of providing an accurate time remaining report and we should trust it.)
+ */
+ int remaining_time = 0;
+
+ /* The total (dis)charge rate of the system is the sum of the rates of
+ * the individual batteries.
+ */
+ int rate_total = 0;
+
+ /* We need to know if we should report the composite battery as present
+ * at all. The logic is that if at least one actual battery is installed
+ * then the composite battery will be reported to exist.
+ */
+ int present = 0;
+
+ /* We need to know if we are on AC power or not. Eventually, we can look
+ * at the AC adaptor HAL devices to determine that. For now, we assume that
+ * if any battery is discharging then we must not be on AC power. Else, by
+ * default, we must be on AC.
+ */
+ int on_ac_power = 1;
+
+ /* Finally, we consider the composite battery to be "charging" if at least
+ * one of the actual batteries in the system is charging.
+ */
+ int charging = 0;
+
+ /* A list iterator. */
+ GSList *item;
+
+ /* For each physical battery bay... */
+ for( item = batteries; item; item = item->next )
+ {
+ struct battery_info *battery = item->data;
+
+ /* If no battery is installed here, don't count it toward the totals. */
+ if( !battery->status.present )
+ continue;
+
+ /* This battery is present. */
+
+ /* At least one battery present -> composite battery is present. */
+ present++;
+
+ /* At least one battery charging -> composite battery is charging. */
+ if( battery->status.charging )
+ charging = 1;
+
+ /* At least one battery is discharging -> we're not on AC. */
+ if( battery->status.discharging )
+ on_ac_power = 0;
+
+ /* Sum the totals for current charge, design capacity, (dis)charge rate. */
+ current_charge_total += battery->status.current_level;
+ full_capacity_total += battery->status.full_level;
+ rate_total += battery->status.rate;
+
+ /* Record remaining time too, incase this is the only battery. */
+ remaining_time = battery->status.remaining_time;
+ }
+
+ if( !present || full_capacity_total <= 0 || (charging && !on_ac_power) )
+ {
+ /* Either no battery is present or something has gone horribly wrong.
+ * In either case we must return that the composite battery is not
+ * present.
+ */
+ status->present = FALSE;
+ status->percent = 0;
+ status->minutes = -1;
+ status->on_ac_power = TRUE;
+ status->charging = FALSE;
+
+ return;
+ }
+
+ /* Else, our composite battery is present. */
+ status->present = TRUE;
+
+ /* As per above, overall charge is:
+ *
+ * Sum( Current charges ) / Sum( Full Capacities )
+ */
+ status->percent = ( ((double) current_charge_total) /
+ ((double) full_capacity_total) ) * 100.0 + 0.5;
+
+ if( present == 1 )
+ {
+ /* In the case of exactly one battery, report the time remaining figure
+ * from HAL directly since it might have come from an authorative source
+ * (ie: the PMU or APM subsystem).
+ *
+ * HAL gives remaining time in seconds with a 0 to mean that the
+ * remaining time is unknown. Battstat uses minutes and -1 for 
+ * unknown time remaining.
+ */
+
+ if( remaining_time == 0 )
+ status->minutes = -1;
+ else
+ status->minutes = (remaining_time + 30) / 60;
+ }
+ /* Rest of cases to deal with multiple battery systems... */
+ else if( !on_ac_power && rate_total != 0 )
+ {
+ /* Then we're discharging. Calculate time remaining until at zero. */
+
+ double remaining;
+
+ remaining = (double) current_charge_total;
+ remaining /= (double) rate_total;
+ status->minutes = (int) floor( remaining * 60.0 + 0.5 );
+ }
+ else if( charging && rate_total != 0 )
+ {
+ /* Calculate time remaining until charged. For systems with more than
+ * one battery, this code is very approximate. The assumption is that if
+ * one battery reaches full charge before the other that the other will
+ * start charging faster due to the increase in available power (similar
+ * to how a laptop will charge faster if you're not using it).
+ */
+
+ double remaining;
+
+ remaining = (double) (full_capacity_total - current_charge_total);
+ if( remaining < 0 )
+ remaining = 0;
+ remaining /= (double) rate_total;
+
+ status->minutes = (int) floor( remaining * 60.0 + 0.5 );
+ }
+ else
+ {
+ /* On AC power and not charging -or- rate is unknown. */
+ status->minutes = -1;
+ }
+
+ /* These are simple and well-explained above. */
+ status->charging = charging;
+ status->on_ac_power = on_ac_power;
+}
+
+#endif /* HAVE_HAL */