← Back to branch summary

~ubuntu-branches/ubuntu/karmic/devicekit-power/karmic-proposed

« back to all changes in this revision

Viewing changes to src/dkp-daemon.c

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2009-07-22 18:08:28 UTC
  • mfrom: (1.3.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20090722180828-zd9mugnpllojb7py
Tags: 010-0ubuntu1
* New upstream release:
  - Port to PolicyKit 1 API.
  - Port from DeviceKit to gudev.
  - Bug fixes.
* debian/control: 
  - libpolkit-dbus-dev → libpolkit-gobject-1-dev build dependency.
  - libdevkit-gobject-dev → libgudev-1.0-dev build dependency.
  - Drop devicekit dependency.
  - Add Conflicts to devicekit. This is not really true in the packaging
    sense, but devicekit only started to exist in earlier karmic and will
    cease to exist now, so clean it up for the benefit of Karmic testers.
    This will be dropped in some weeks.
* Drop 0001-Add-a-notify-flag-to-set_lid_is_closed.patch, fixed upstream.
* Add Breaks to gnome-power-manager versions which aren't ported to new
  PolicyKit API yet.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/dkp-daemon.c
24
24
#endif
25
25
 
26
26
#include <string.h>
 
27
#include <stdlib.h>
27
28
 
28
29
#include <glib.h>
29
30
#include <glib/gi18n-lib.h>
30
31
#include <glib-object.h>
31
32
#include <dbus/dbus-glib.h>
32
33
#include <dbus/dbus-glib-lowlevel.h>
33
 
#include <devkit-gobject/devkit-gobject.h>
 
34
#include <gudev/gudev.h>
34
35
 
35
36
#include "egg-debug.h"
36
37
 
82
83
        DkpDeviceList           *managed_devices;
83
84
        gboolean                 on_battery;
84
85
        gboolean                 low_battery;
85
 
        DevkitClient            *devkit_client;
 
86
        GUdevClient             *gudev_client;
86
87
        gboolean                 lid_is_closed;
87
88
        gboolean                 lid_is_present;
 
89
        gboolean                 can_suspend;
 
90
        gboolean                 can_hibernate;
88
91
};
89
92
 
90
93
static void     dkp_daemon_class_init           (DkpDaemonClass *klass);
98
101
 
99
102
#define DKP_DAEMON_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), DKP_TYPE_DAEMON, DkpDaemonPrivate))
100
103
 
 
104
/* if using more memory compared to usable swap, disable hibernate */
 
105
#define DKP_DAEMON_SWAP_WATERLINE                       80.0f /* % */
 
106
 
 
107
/* refresh all the devices after this much time when on-battery has changed */
 
108
#define DKP_DAEMON_ON_BATTERY_REFRESH_DEVICES_DELAY     3 /* seconds */
 
109
 
 
110
static gboolean dkp_daemon_device_add (DkpDaemon *daemon, GUdevDevice *d, gboolean emit_event);
 
111
static void dkp_daemon_device_remove (DkpDaemon *daemon, GUdevDevice *d);
 
112
 
101
113
/**
102
114
 * dkp_daemon_set_lid_is_closed:
103
115
 **/
104
116
gboolean
105
 
dkp_daemon_set_lid_is_closed (DkpDaemon *daemon, gboolean lid_is_closed)
 
117
dkp_daemon_set_lid_is_closed (DkpDaemon *daemon, gboolean lid_is_closed, gboolean notify)
106
118
{
107
119
        gboolean ret = FALSE;
108
 
        static gboolean initialized = FALSE;
109
120
 
110
121
        g_return_val_if_fail (DKP_IS_DAEMON (daemon), FALSE);
111
122
 
116
127
        }
117
128
 
118
129
        /* save */
119
 
        if (!initialized) {
 
130
        if (!notify) {
120
131
                /* Do not emit an event on startup. Otherwise, e. g.
121
132
                 * gnome-power-manager would pick up a "lid is closed" change
122
133
                 * event when dk-p gets D-BUS activated, and thus would
123
134
                 * immediately suspend the machine on startup. FD#22574 */
124
135
                egg_debug ("not emitting lid change event for daemon startup");
125
 
                initialized = TRUE;
126
136
        } else {
127
137
                g_signal_emit (daemon, signals[CHANGED_SIGNAL], 0);
128
138
        }
202
212
                break;
203
213
 
204
214
        case PROP_CAN_SUSPEND:
205
 
                /* TODO: for now assume we can always suspend */
206
 
                g_value_set_boolean (value, TRUE);
 
215
                g_value_set_boolean (value, daemon->priv->can_suspend);
207
216
                break;
208
217
 
209
218
        case PROP_CAN_HIBERNATE:
210
 
                /* TODO for now assume we can always hibernate */
211
 
                g_value_set_boolean (value, TRUE);
 
219
                g_value_set_boolean (value, daemon->priv->can_hibernate);
212
220
                break;
213
221
 
214
222
        case PROP_ON_BATTERY:
305
313
                                                               G_PARAM_READABLE));
306
314
 
307
315
        g_object_class_install_property (object_class,
308
 
                                         PROP_CAN_SUSPEND,
 
316
                                         PROP_CAN_HIBERNATE,
309
317
                                         g_param_spec_boolean ("can-hibernate",
310
318
                                                               "Can Hibernate",
311
319
                                                               "Whether the system can hibernate",
342
350
}
343
351
 
344
352
/**
 
353
 * dkp_daemon_check_state:
 
354
 **/
 
355
static gboolean
 
356
dkp_daemon_check_state (DkpDaemon *daemon)
 
357
{
 
358
        gchar *contents = NULL;
 
359
        GError *error = NULL;
 
360
        gboolean ret;
 
361
        const gchar *filename = "/sys/power/state";
 
362
 
 
363
        /* see what kernel can do */
 
364
        ret = g_file_get_contents (filename, &contents, NULL, &error);
 
365
        if (!ret) {
 
366
                egg_warning ("failed to open %s: %s", filename, error->message);
 
367
                g_error_free (error);
 
368
                goto out;
 
369
        }
 
370
 
 
371
        /* does the kernel advertise this */
 
372
        daemon->priv->can_suspend = (g_strstr_len (contents, -1, "mem") != NULL);
 
373
        daemon->priv->can_hibernate = (g_strstr_len (contents, -1, "disk") != NULL);
 
374
out:
 
375
        g_free (contents);
 
376
        return ret;
 
377
}
 
378
 
 
379
/**
 
380
 * dkp_daemon_check_swap:
 
381
 **/
 
382
static gfloat
 
383
dkp_daemon_check_swap (DkpDaemon *daemon)
 
384
{
 
385
        gchar *contents = NULL;
 
386
        gchar **lines = NULL;
 
387
        GError *error = NULL;
 
388
        gchar **tokens;
 
389
        gboolean ret;
 
390
        guint active = 0;
 
391
        guint swap_free = 0;
 
392
        guint len;
 
393
        guint i;
 
394
        gfloat percentage = 0.0f;
 
395
        const gchar *filename = "/proc/meminfo";
 
396
 
 
397
        /* get memory data */
 
398
        ret = g_file_get_contents (filename, &contents, NULL, &error);
 
399
        if (!ret) {
 
400
                egg_warning ("failed to open %s: %s", filename, error->message);
 
401
                g_error_free (error);
 
402
                goto out;
 
403
        }
 
404
 
 
405
        /* process each line */
 
406
        lines = g_strsplit (contents, "\n", -1);
 
407
        for (i=1; lines[i] != NULL; i++) {
 
408
                tokens = g_strsplit_set (lines[i], ": ", -1);
 
409
                len = g_strv_length (tokens);
 
410
                if (len > 3) {
 
411
                        if (g_strcmp0 (tokens[0], "SwapFree") == 0)
 
412
                                swap_free = atoi (tokens[len-2]);
 
413
                        else if (g_strcmp0 (tokens[0], "Active") == 0)
 
414
                                active = atoi (tokens[len-2]);
 
415
                }
 
416
                g_strfreev (tokens);
 
417
        }
 
418
 
 
419
        /* work out how close to the line we are */
 
420
        if (swap_free > 0 && active > 0)
 
421
                percentage = (active * 100) / swap_free;
 
422
        egg_debug ("total swap available %i kb, active memory %i kb (%.1f%%)", swap_free, active, percentage);
 
423
out:
 
424
        g_free (contents);
 
425
        g_strfreev (lines);
 
426
        return percentage;
 
427
}
 
428
 
 
429
/**
345
430
 * dkp_daemon_init:
346
431
 **/
347
432
static void
348
433
dkp_daemon_init (DkpDaemon *daemon)
349
434
{
 
435
        gfloat waterline;
 
436
 
350
437
        daemon->priv = DKP_DAEMON_GET_PRIVATE (daemon);
351
438
        daemon->priv->polkit = dkp_polkit_new ();
352
439
        daemon->priv->lid_is_present = FALSE;
353
440
        daemon->priv->lid_is_closed = FALSE;
 
441
        daemon->priv->can_suspend = FALSE;
 
442
        daemon->priv->can_hibernate = FALSE;
 
443
 
 
444
        /* check if we have support */
 
445
        dkp_daemon_check_state (daemon);
 
446
 
 
447
        /* do we have enough swap? */
 
448
        if (daemon->priv->can_hibernate) {
 
449
                waterline = dkp_daemon_check_swap (daemon);
 
450
                if (waterline > DKP_DAEMON_SWAP_WATERLINE) {
 
451
                        egg_debug ("not enough swap to enable hibernate");
 
452
                        daemon->priv->can_hibernate = FALSE;
 
453
                }
 
454
        }
354
455
}
355
456
 
356
457
/**
372
473
                g_object_unref (daemon->priv->proxy);
373
474
        if (daemon->priv->connection != NULL)
374
475
                dbus_g_connection_unref (daemon->priv->connection);
375
 
        if (daemon->priv->devkit_client != NULL)
376
 
                g_object_unref (daemon->priv->devkit_client);
 
476
        if (daemon->priv->gudev_client != NULL)
 
477
                g_object_unref (daemon->priv->gudev_client);
377
478
        if (daemon->priv->power_devices != NULL)
378
479
                g_object_unref (daemon->priv->power_devices);
379
480
        if (daemon->priv->managed_devices != NULL)
383
484
        G_OBJECT_CLASS (dkp_daemon_parent_class)->finalize (object);
384
485
}
385
486
 
386
 
static gboolean dkp_daemon_device_add (DkpDaemon *daemon, DevkitDevice *d, gboolean emit_event);
387
 
static void dkp_daemon_device_remove (DkpDaemon *daemon, DevkitDevice *d);
388
 
 
389
487
/**
390
488
 * dkp_daemon_get_on_battery_local:
391
489
 *
415
513
}
416
514
 
417
515
/**
 
516
 * dkp_daemon_get_number_devices_of_type:
 
517
 **/
 
518
guint
 
519
dkp_daemon_get_number_devices_of_type (DkpDaemon *daemon, DkpDeviceType type)
 
520
{
 
521
        guint i;
 
522
        DkpDevice *device;
 
523
        const GPtrArray *array;
 
524
        DkpDeviceType type_tmp;
 
525
        guint count = 0;
 
526
 
 
527
        /* ask each device */
 
528
        array = dkp_device_list_get_array (daemon->priv->power_devices);
 
529
        for (i=0; i<array->len; i++) {
 
530
                device = (DkpDevice *) g_ptr_array_index (array, i);
 
531
                g_object_get (device,
 
532
                              "type", &type_tmp,
 
533
                              NULL);
 
534
                if (type == type_tmp)
 
535
                        count++;
 
536
        }
 
537
        return count;
 
538
}
 
539
 
 
540
/**
418
541
 * dkp_daemon_get_low_battery_local:
419
542
 *
420
543
 * As soon as _all_ batteries are low, this is true
497
620
}
498
621
 
499
622
/**
 
623
 * dkp_daemon_refresh_battery_devices:
 
624
 **/
 
625
static gboolean
 
626
dkp_daemon_refresh_battery_devices (DkpDaemon *daemon)
 
627
{
 
628
        guint i;
 
629
        const GPtrArray *array;
 
630
        DkpDevice *device;
 
631
        DkpDeviceType type;
 
632
 
 
633
        /* refresh all devices in array */
 
634
        array = dkp_device_list_get_array (daemon->priv->power_devices);
 
635
        for (i=0; i<array->len; i++) {
 
636
                device = (DkpDevice *) g_ptr_array_index (array, i);
 
637
                /* only refresh battery devices */
 
638
                g_object_get (device,
 
639
                              "type", &type,
 
640
                              NULL);
 
641
                if (type == DKP_DEVICE_TYPE_BATTERY)
 
642
                        dkp_device_refresh_internal (device);
 
643
        }
 
644
 
 
645
        return TRUE;
 
646
}
 
647
 
 
648
/**
 
649
 * dkp_daemon_refresh_battery_devices_cb:
 
650
 **/
 
651
static gboolean
 
652
dkp_daemon_refresh_battery_devices_cb (DkpDaemon *daemon)
 
653
{
 
654
        egg_debug ("doing the delayed refresh");
 
655
        dkp_daemon_refresh_battery_devices (daemon);
 
656
        return FALSE;
 
657
}
 
658
 
 
659
/**
500
660
 * dkp_daemon_device_changed:
501
661
 **/
502
662
static void
503
 
dkp_daemon_device_changed (DkpDaemon *daemon, DevkitDevice *d, gboolean synthesized)
 
663
dkp_daemon_device_changed (DkpDaemon *daemon, GUdevDevice *d, gboolean synthesized)
504
664
{
505
665
        GObject *object;
506
666
        DkpDevice *device;
 
667
        DkpDeviceType type;
507
668
        gboolean ret;
508
669
 
509
670
        /* first, change the device and add it if it doesn't exist */
512
673
                device = DKP_DEVICE (object);
513
674
                egg_debug ("changed %s", dkp_device_get_object_path (device));
514
675
                dkp_device_changed (device, d, synthesized);
 
676
 
 
677
                /* refresh battery devices when AC state changes */
 
678
                g_object_get (device,
 
679
                              "type", &type,
 
680
                              NULL);
 
681
                if (type == DKP_DEVICE_TYPE_LINE_POWER) {
 
682
                        /* refresh now, and again in a little while */
 
683
                        dkp_daemon_refresh_battery_devices (daemon);
 
684
                        g_timeout_add_seconds (DKP_DAEMON_ON_BATTERY_REFRESH_DEVICES_DELAY,
 
685
                                               (GSourceFunc) dkp_daemon_refresh_battery_devices_cb, daemon);
 
686
                }
 
687
 
515
688
        } else {
516
 
                egg_debug ("treating change event as add on %s", devkit_device_get_native_path (d));
 
689
                egg_debug ("treating change event as add on %s", g_udev_device_get_sysfs_path (d));
517
690
                dkp_daemon_device_add (daemon, d, TRUE);
518
691
        }
519
692
 
549
722
 * dkp_daemon_device_get:
550
723
 **/
551
724
static DkpDevice *
552
 
dkp_daemon_device_get (DkpDaemon *daemon, DevkitDevice *d)
 
725
dkp_daemon_device_get (DkpDaemon *daemon, GUdevDevice *d)
553
726
{
554
727
        const gchar *subsys;
555
728
        const gchar *native_path;
557
730
        DkpInput *input;
558
731
        gboolean ret;
559
732
 
560
 
        subsys = devkit_device_get_subsystem (d);
 
733
        subsys = g_udev_device_get_subsystem (d);
561
734
        if (g_strcmp0 (subsys, "power_supply") == 0) {
562
735
 
563
736
                /* are we a valid power supply */
621
794
                device = NULL;
622
795
 
623
796
        } else {
624
 
                native_path = devkit_device_get_native_path (d);
 
797
                native_path = g_udev_device_get_sysfs_path (d);
625
798
                egg_warning ("native path %s (%s) ignoring", native_path, subsys);
626
799
        }
627
800
out:
632
805
 * dkp_daemon_device_add:
633
806
 **/
634
807
static gboolean
635
 
dkp_daemon_device_add (DkpDaemon *daemon, DevkitDevice *d, gboolean emit_event)
 
808
dkp_daemon_device_add (DkpDaemon *daemon, GUdevDevice *d, gboolean emit_event)
636
809
{
637
810
        GObject *object;
638
811
        DkpDevice *device;
650
823
                /* get the right sort of device */
651
824
                device = dkp_daemon_device_get (daemon, d);
652
825
                if (device == NULL) {
653
 
                        egg_debug ("not adding device %s", devkit_device_get_native_path (d));
 
826
                        egg_debug ("not adding device %s", g_udev_device_get_sysfs_path (d));
654
827
                        ret = FALSE;
655
828
                        goto out;
656
829
                }
672
845
 * dkp_daemon_device_remove:
673
846
 **/
674
847
static void
675
 
dkp_daemon_device_remove (DkpDaemon *daemon, DevkitDevice *d)
 
848
dkp_daemon_device_remove (DkpDaemon *daemon, GUdevDevice *d)
676
849
{
677
850
        GObject *object;
678
851
        DkpDevice *device;
680
853
        /* does device exist in db? */
681
854
        object = dkp_device_list_lookup (daemon->priv->power_devices, d);
682
855
        if (object == NULL) {
683
 
                egg_debug ("ignoring remove event on %s", devkit_device_get_native_path (d));
 
856
                egg_debug ("ignoring remove event on %s", g_udev_device_get_sysfs_path (d));
684
857
        } else {
685
858
                device = DKP_DEVICE (object);
686
859
                dkp_device_removed (device);
691
864
}
692
865
 
693
866
/**
694
 
 * dkp_daemon_device_event_signal_handler:
 
867
 * dkp_daemon_uevent_signal_handler_cb:
695
868
 **/
696
869
static void
697
 
dkp_daemon_device_event_signal_handler (DevkitClient *client, const char *action,
698
 
                                        DevkitDevice *device, gpointer user_data)
 
870
dkp_daemon_uevent_signal_handler_cb (GUdevClient *client, const gchar *action,
 
871
                                     GUdevDevice *device, gpointer user_data)
699
872
{
700
873
        DkpDaemon *daemon = DKP_DAEMON (user_data);
701
874
 
702
875
        if (g_strcmp0 (action, "add") == 0) {
703
 
                egg_debug ("add %s", devkit_device_get_native_path (device));
 
876
                egg_debug ("add %s", g_udev_device_get_sysfs_path (device));
704
877
                dkp_daemon_device_add (daemon, device, TRUE);
705
878
        } else if (g_strcmp0 (action, "remove") == 0) {
706
 
                egg_debug ("remove %s", devkit_device_get_native_path (device));
 
879
                egg_debug ("remove %s", g_udev_device_get_sysfs_path (device));
707
880
                dkp_daemon_device_remove (daemon, device);
708
881
        } else if (g_strcmp0 (action, "change") == 0) {
709
 
                egg_debug ("change %s", devkit_device_get_native_path (device));
 
882
                egg_debug ("change %s", g_udev_device_get_sysfs_path (device));
710
883
                dkp_daemon_device_changed (daemon, device, FALSE);
711
884
        } else {
712
 
                egg_warning ("unhandled action '%s' on %s", action, devkit_device_get_native_path (device));
 
885
                egg_warning ("unhandled action '%s' on %s", action, g_udev_device_get_sysfs_path (device));
713
886
        }
714
887
}
715
888
 
750
923
        gboolean ret;
751
924
        GError *error;
752
925
        GError *error_local = NULL;
753
 
        PolKitCaller *caller;
 
926
        PolkitSubject *subject;
754
927
        gchar *stdout = NULL;
755
928
        gchar *stderr = NULL;
756
929
 
757
 
        caller = dkp_polkit_get_caller (daemon->priv->polkit, context);
758
 
        if (caller == NULL)
 
930
        subject = dkp_polkit_get_subject (daemon->priv->polkit, context);
 
931
        if (subject == NULL)
759
932
                goto out;
760
933
 
761
 
        if (!dkp_polkit_check_auth (daemon->priv->polkit, caller, "org.freedesktop.devicekit.power.suspend", context))
 
934
        if (!dkp_polkit_check_auth (daemon->priv->polkit, subject, "org.freedesktop.devicekit.power.suspend", context))
762
935
                goto out;
763
936
 
764
937
        ret = g_spawn_command_line_sync ("/usr/sbin/pm-suspend", &stdout, &stderr, NULL, &error_local);
774
947
out:
775
948
        g_free (stdout);
776
949
        g_free (stderr);
777
 
        if (caller != NULL)
778
 
                polkit_caller_unref (caller);
 
950
        if (subject != NULL)
 
951
                g_object_unref (subject);
779
952
        return TRUE;
780
953
}
781
954
 
788
961
        gboolean ret;
789
962
        GError *error;
790
963
        GError *error_local = NULL;
791
 
        PolKitCaller *caller;
 
964
        PolkitSubject *subject;
792
965
        gchar *stdout = NULL;
793
966
        gchar *stderr = NULL;
794
967
 
795
 
        caller = dkp_polkit_get_caller (daemon->priv->polkit, context);
796
 
        if (caller == NULL)
 
968
        subject = dkp_polkit_get_subject (daemon->priv->polkit, context);
 
969
        if (subject == NULL)
797
970
                goto out;
798
971
 
799
 
        if (!dkp_polkit_check_auth (daemon->priv->polkit, caller, "org.freedesktop.devicekit.power.hibernate", context))
 
972
        if (!dkp_polkit_check_auth (daemon->priv->polkit, subject, "org.freedesktop.devicekit.power.hibernate", context))
800
973
                goto out;
801
974
 
802
975
        ret = g_spawn_command_line_sync ("/usr/sbin/pm-hibernate", &stdout, &stderr, NULL, &error_local);
812
985
out:
813
986
        g_free (stdout);
814
987
        g_free (stderr);
815
 
        if (caller != NULL)
816
 
                polkit_caller_unref (caller);
 
988
        if (subject != NULL)
 
989
                g_object_unref (subject);
817
990
        return TRUE;
818
991
}
819
992
 
858
1031
        for (i=0; subsystems[i] != NULL; i++)
859
1032
                egg_debug ("registering subsystem : %s", subsystems[i]);
860
1033
 
861
 
        daemon->priv->devkit_client = devkit_client_new (subsystems);
862
 
        if (!devkit_client_connect (daemon->priv->devkit_client, &error)) {
863
 
                egg_warning ("Couldn't open connection to DeviceKit daemon: %s", error->message);
864
 
                g_error_free (error);
865
 
                goto error;
866
 
        }
867
 
        g_signal_connect (daemon->priv->devkit_client, "device-event",
868
 
                          G_CALLBACK (dkp_daemon_device_event_signal_handler), daemon);
 
1034
        daemon->priv->gudev_client = g_udev_client_new (subsystems);
 
1035
        g_signal_connect (daemon->priv->gudev_client, "uevent",
 
1036
                          G_CALLBACK (dkp_daemon_uevent_signal_handler_cb), daemon);
869
1037
 
870
1038
        return TRUE;
871
1039
error:
879
1047
dkp_daemon_new (void)
880
1048
{
881
1049
        DkpDaemon *daemon;
882
 
        GError *error = NULL;
 
1050
        GUdevDevice *device;
883
1051
        GList *devices;
884
1052
        GList *l;
 
1053
        guint i;
885
1054
 
886
1055
        daemon = DKP_DAEMON (g_object_new (DKP_TYPE_DAEMON, NULL));
887
1056
 
893
1062
                return NULL;
894
1063
        }
895
1064
 
896
 
        devices = devkit_client_enumerate_by_subsystem (daemon->priv->devkit_client, subsystems, &error);
897
 
        if (error != NULL) {
898
 
                egg_warning ("Cannot enumerate devices: %s", error->message);
899
 
                g_error_free (error);
900
 
                g_object_unref (daemon);
901
 
                return NULL;
902
 
        }
903
 
 
904
 
        for (l = devices; l != NULL; l = l->next) {
905
 
                DevkitDevice *device = l->data;
906
 
                dkp_daemon_device_add (daemon, device, FALSE);
907
 
        }
908
 
        g_list_foreach (devices, (GFunc) g_object_unref, NULL);
909
 
        g_list_free (devices);
 
1065
        /* add all subsystems */
 
1066
        for (i=0; subsystems[i] != NULL; i++) {
 
1067
                devices = g_udev_client_query_by_subsystem (daemon->priv->gudev_client, subsystems[i]);
 
1068
                for (l = devices; l != NULL; l = l->next) {
 
1069
                        device = l->data;
 
1070
                        dkp_daemon_device_add (daemon, device, FALSE);
 
1071
                }
 
1072
                g_list_foreach (devices, (GFunc) g_object_unref, NULL);
 
1073
                g_list_free (devices);
 
1074
        }
910
1075
 
911
1076
        daemon->priv->on_battery = (dkp_daemon_get_on_battery_local (daemon) &&
912
1077
                                    !dkp_daemon_get_on_ac_local (daemon));