LCOV - code coverage report
Current view: top level - src/plugins/battery - valent-battery-plugin.c (source / functions) Hit Total Coverage
Test: Code Coverage Lines: 215 224 96.0 %
Date: 2023-06-06 02:20:50 Functions: 18 19 94.7 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 94 138 68.1 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-3.0-or-later
       2                 :            : // SPDX-FileCopyrightText: Andy Holmes <andrew.g.r.holmes@gmail.com>
       3                 :            : 
       4                 :            : #define G_LOG_DOMAIN "valent-battery-plugin"
       5                 :            : 
       6                 :            : #include "config.h"
       7                 :            : 
       8                 :            : #include <math.h>
       9                 :            : 
      10                 :            : #include <glib/gi18n.h>
      11                 :            : #include <gio/gio.h>
      12                 :            : #include <valent.h>
      13                 :            : 
      14                 :            : #include "valent-battery.h"
      15                 :            : #include "valent-battery-plugin.h"
      16                 :            : 
      17                 :            : /* Defaults are 90m charge, 1d discharge (seconds/percent) */
      18                 :            : #define DEFAULT_CHARGE_RATE    (90*60/100)
      19                 :            : #define DEFAULT_DISCHARGE_RATE (24*60*60/100)
      20                 :            : 
      21                 :            : 
      22                 :            : struct _ValentBatteryPlugin
      23                 :            : {
      24                 :            :   ValentDevicePlugin  parent_instance;
      25                 :            : 
      26                 :            :   /* Local Battery */
      27                 :            :   ValentBattery      *battery;
      28                 :            :   unsigned int        battery_watch : 1;
      29                 :            : 
      30                 :            :   /* Remote Battery */
      31                 :            :   gboolean            charging;
      32                 :            :   const char         *icon_name;
      33                 :            :   gboolean            is_present;
      34                 :            :   double              percentage;
      35                 :            :   int64_t             time_to_full;
      36                 :            :   int64_t             time_to_empty;
      37                 :            :   int64_t             charge_rate;
      38                 :            :   int64_t             discharge_rate;
      39                 :            :   int64_t             timestamp;
      40                 :            : };
      41                 :            : 
      42                 :            : static const char * valent_battery_plugin_get_icon_name (ValentBatteryPlugin *self);
      43                 :            : static void         valent_battery_plugin_request_state (ValentBatteryPlugin *self);
      44                 :            : static void         valent_battery_plugin_send_state    (ValentBatteryPlugin *self);
      45                 :            : 
      46   [ +  +  +  - ]:        154 : G_DEFINE_FINAL_TYPE (ValentBatteryPlugin, valent_battery_plugin, VALENT_TYPE_DEVICE_PLUGIN)
      47                 :            : 
      48                 :            : 
      49                 :            : /*
      50                 :            :  * Local Battery
      51                 :            :  */
      52                 :            : static void
      53                 :          4 : on_battery_changed (ValentBattery       *battery,
      54                 :            :                     ValentBatteryPlugin *self)
      55                 :            : {
      56         [ +  - ]:          4 :   g_assert (VALENT_IS_BATTERY (battery));
      57         [ -  + ]:          4 :   g_assert (VALENT_IS_BATTERY_PLUGIN (self));
      58                 :            : 
      59                 :          4 :   valent_battery_plugin_send_state (self);
      60                 :          4 : }
      61                 :            : 
      62                 :            : static void
      63                 :         30 : valent_battery_plugin_watch_battery (ValentBatteryPlugin *self,
      64                 :            :                                      gboolean             watch)
      65                 :            : {
      66         [ +  - ]:         30 :   g_assert (VALENT_IS_BATTERY_PLUGIN (self));
      67                 :            : 
      68         [ +  + ]:         30 :   if (self->battery_watch == watch)
      69                 :            :     return;
      70                 :            : 
      71         [ +  + ]:         10 :   if (self->battery == NULL)
      72                 :          5 :     self->battery = valent_battery_get_default ();
      73                 :            : 
      74         [ +  + ]:         10 :   if (watch)
      75                 :            :     {
      76                 :          5 :       g_signal_connect_object (self->battery,
      77                 :            :                                "changed",
      78                 :            :                                G_CALLBACK (on_battery_changed),
      79                 :            :                                self, 0);
      80                 :          5 :       self->battery_watch = TRUE;
      81                 :            :     }
      82                 :            :   else
      83                 :            :     {
      84                 :          5 :       g_signal_handlers_disconnect_by_data (self->battery, self);
      85                 :          5 :       self->battery_watch = FALSE;
      86                 :            :     }
      87                 :            : }
      88                 :            : 
      89                 :            : static void
      90                 :          1 : valent_battery_plugin_handle_battery_request (ValentBatteryPlugin *self,
      91                 :            :                                               JsonNode            *packet)
      92                 :            : {
      93         [ +  - ]:          1 :   g_assert (VALENT_IS_BATTERY_PLUGIN (self));
      94         [ -  + ]:          1 :   g_assert (VALENT_IS_PACKET (packet));
      95                 :            : 
      96         [ +  - ]:          1 :   if (valent_packet_check_field (packet, "request"))
      97                 :          1 :     valent_battery_plugin_send_state (self);
      98                 :          1 : }
      99                 :            : 
     100                 :            : static void
     101                 :          5 : valent_battery_plugin_send_state (ValentBatteryPlugin *self)
     102                 :            : {
     103                 :          5 :   g_autoptr (JsonBuilder) builder = NULL;
     104   [ -  +  -  + ]:          5 :   g_autoptr (JsonNode) packet = NULL;
     105                 :          5 :   GSettings *settings;
     106                 :          5 :   int current_charge;
     107                 :          5 :   gboolean is_charging;
     108                 :          5 :   unsigned int threshold_event;
     109                 :            : 
     110         [ +  - ]:          5 :   g_return_if_fail (VALENT_IS_BATTERY_PLUGIN (self));
     111                 :            : 
     112         [ +  - ]:          5 :   if (!valent_battery_is_present (self->battery))
     113                 :            :     return;
     114                 :            : 
     115                 :            :   /* If the level is zero or less it's probably bogus, so send nothing */
     116         [ +  + ]:          5 :   if (valent_battery_current_charge (self->battery) <= 0)
     117                 :            :     return;
     118                 :            : 
     119                 :          4 :   settings = valent_extension_get_settings (VALENT_EXTENSION (self));
     120                 :            : 
     121         [ +  - ]:          4 :   if (!g_settings_get_boolean (settings, "share-state"))
     122                 :            :     return;
     123                 :            : 
     124                 :          4 :   current_charge = valent_battery_current_charge (self->battery);
     125                 :          4 :   is_charging = valent_battery_is_charging (self->battery);
     126                 :          4 :   threshold_event = valent_battery_threshold_event (self->battery);
     127                 :            : 
     128                 :          4 :   valent_packet_init (&builder, "kdeconnect.battery");
     129                 :          4 :   json_builder_set_member_name (builder, "currentCharge");
     130                 :          4 :   json_builder_add_int_value (builder, current_charge);
     131                 :          4 :   json_builder_set_member_name (builder, "isCharging");
     132                 :          4 :   json_builder_add_boolean_value (builder, is_charging);
     133                 :          4 :   json_builder_set_member_name (builder, "thresholdEvent");
     134                 :          4 :   json_builder_add_int_value (builder, threshold_event);
     135                 :          4 :   packet = valent_packet_end (&builder);
     136                 :            : 
     137         [ +  - ]:          4 :   valent_device_plugin_queue_packet (VALENT_DEVICE_PLUGIN (self), packet);
     138                 :            : }
     139                 :            : 
     140                 :            : 
     141                 :            : /*
     142                 :            :  * Remote Battery
     143                 :            :  */
     144                 :            : static const char *
     145                 :         17 : valent_battery_plugin_get_icon_name (ValentBatteryPlugin *self)
     146                 :            : {
     147         [ +  + ]:         17 :   if (!self->is_present)
     148                 :            :     return "battery-missing-symbolic";
     149                 :            : 
     150         [ +  + ]:         16 :   if (self->percentage >= 100.0)
     151                 :            :     return "battery-full-charged-symbolic";
     152                 :            : 
     153         [ +  + ]:         14 :   if (self->percentage < 5.0)
     154                 :          1 :     return self->charging
     155                 :            :       ? "battery-empty-charging-symbolic"
     156         [ -  + ]:          1 :       : "battery-empty-symbolic";
     157                 :            : 
     158         [ +  + ]:         13 :   if (self->percentage < 20.0)
     159                 :          2 :     return self->charging
     160                 :            :       ? "battery-caution-charging-symbolic"
     161         [ -  + ]:          2 :       : "battery-caution-symbolic";
     162                 :            : 
     163         [ +  + ]:         11 :   if (self->percentage < 30.0)
     164                 :          2 :     return self->charging
     165                 :            :       ? "battery-low-charging-symbolic"
     166         [ +  + ]:          2 :       : "battery-low-symbolic";
     167                 :            : 
     168         [ +  + ]:          9 :   if (self->percentage < 60.0)
     169                 :          4 :     return self->charging
     170                 :            :       ? "battery-good-charging-symbolic"
     171         [ +  + ]:          4 :       : "battery-good-symbolic";
     172                 :            : 
     173                 :          5 :   return self->charging
     174                 :            :     ? "battery-full-charging-symbolic"
     175         [ +  + ]:          5 :     : "battery-full-symbolic";
     176                 :            : }
     177                 :            : 
     178                 :            : static void
     179                 :         16 : valent_battery_plugin_update_estimate (ValentBatteryPlugin *self,
     180                 :            :                                        int64_t              current_charge,
     181                 :            :                                        gboolean             is_charging)
     182                 :            : {
     183                 :         16 :   int64_t rate;
     184                 :         16 :   double percentage;
     185                 :         16 :   int64_t timestamp;
     186                 :            : 
     187         [ +  - ]:         16 :   g_return_if_fail (current_charge >= 0);
     188                 :            : 
     189   [ +  -  +  - ]:         16 :   percentage = CLAMP (current_charge, 0.0, 100.0);
     190                 :         16 :   timestamp = floor (valent_timestamp_ms () / 1000);
     191         [ +  + ]:         16 :   rate = is_charging ? self->charge_rate : self->discharge_rate;
     192                 :            : 
     193                 :            :   /* If the battery is present, we must have a timestamp and charge level to
     194                 :            :    * calculate the deltas and derive the (dis)charge rate. */
     195         [ +  + ]:         16 :   if (self->is_present)
     196                 :            :     {
     197                 :         14 :       double percentage_delta;
     198                 :         14 :       int64_t timestamp_delta;
     199                 :         14 :       int64_t new_rate;
     200                 :            : 
     201         [ -  + ]:         14 :       percentage_delta = ABS (percentage - self->percentage);
     202                 :         14 :       timestamp_delta = timestamp - self->timestamp;
     203                 :         14 :       new_rate = timestamp_delta / percentage_delta;
     204                 :         14 :       rate = floor ((rate * 0.4) + (new_rate * 0.6));
     205                 :            :     }
     206                 :            : 
     207                 :            :   /* Update the estimate and related values */
     208         [ +  + ]:         16 :   if (is_charging)
     209                 :            :     {
     210                 :          8 :       self->charge_rate = rate;
     211                 :          8 :       self->time_to_empty = 0;
     212                 :          8 :       self->time_to_full = floor (self->charge_rate * (100.0 - percentage));
     213                 :          8 :       self->timestamp = timestamp;
     214                 :            :     }
     215                 :            :   else
     216                 :            :     {
     217                 :          8 :       self->discharge_rate = rate;
     218                 :          8 :       self->time_to_empty = floor (self->discharge_rate * percentage);
     219                 :          8 :       self->time_to_full = 0;
     220                 :          8 :       self->timestamp = timestamp;
     221                 :            :     }
     222                 :            : }
     223                 :            : 
     224                 :            : static void
     225                 :         28 : valent_battery_plugin_update_gaction (ValentBatteryPlugin *self)
     226                 :            : {
     227                 :         28 :   GVariantDict dict;
     228                 :         28 :   GVariant *state;
     229                 :         28 :   GAction *action;
     230                 :            : 
     231         [ +  - ]:         28 :   g_assert (VALENT_IS_BATTERY_PLUGIN (self));
     232                 :            : 
     233                 :         28 :   g_variant_dict_init (&dict, NULL);
     234                 :         28 :   g_variant_dict_insert (&dict, "charging", "b", self->charging);
     235                 :         28 :   g_variant_dict_insert (&dict, "percentage", "d", self->percentage);
     236                 :         28 :   g_variant_dict_insert (&dict, "icon-name", "s", self->icon_name);
     237                 :         28 :   g_variant_dict_insert (&dict, "is-present", "b", self->is_present);
     238                 :         28 :   g_variant_dict_insert (&dict, "time-to-empty", "x", self->time_to_empty);
     239                 :         28 :   g_variant_dict_insert (&dict, "time-to-full", "x", self->time_to_full);
     240                 :         28 :   state = g_variant_dict_end (&dict);
     241                 :            : 
     242                 :            :   /* Update the state, even if we're disabling the action */
     243                 :         28 :   action = g_action_map_lookup_action (G_ACTION_MAP (self), "state");
     244                 :         28 :   g_simple_action_set_enabled (G_SIMPLE_ACTION (action), self->is_present);
     245                 :         28 :   g_simple_action_set_state (G_SIMPLE_ACTION (action), state);
     246                 :         28 : }
     247                 :            : 
     248                 :            : static void
     249                 :         17 : valent_battery_plugin_update_notification (ValentBatteryPlugin *self,
     250                 :            :                                            int                  threshold_event)
     251                 :            : {
     252                 :         15 :   g_autoptr (GNotification) notification = NULL;
     253         [ +  - ]:         17 :   g_autofree char *title = NULL;
     254                 :         17 :   g_autofree char *body = NULL;
     255                 :         17 :   g_autoptr (GIcon) icon = NULL;
     256                 :         17 :   ValentDevice *device;
     257                 :         17 :   const char *device_name;
     258                 :         17 :   GSettings *settings;
     259                 :         17 :   double full, low;
     260                 :            : 
     261         [ +  - ]:         17 :   g_assert (VALENT_IS_BATTERY_PLUGIN (self));
     262                 :            : 
     263                 :         17 :   device = valent_extension_get_object (VALENT_EXTENSION (self));
     264                 :         17 :   device_name = valent_device_get_name (device);
     265                 :         17 :   settings = valent_extension_get_settings (VALENT_EXTENSION (self));
     266                 :            : 
     267                 :         17 :   full = g_settings_get_double (settings, "full-notification-level");
     268                 :         17 :   low = g_settings_get_double (settings, "low-notification-level");
     269                 :            : 
     270         [ +  + ]:         17 :   if (self->percentage >= full)
     271                 :            :     {
     272         [ -  + ]:          2 :       if (!g_settings_get_boolean (settings, "full-notification"))
     273                 :            :         return;
     274                 :            : 
     275                 :            :       /* TRANSLATORS: This is <device name>: Fully Charged */
     276                 :          0 :       title = g_strdup_printf (_("%s: Fully Charged"), device_name);
     277                 :            :       /* TRANSLATORS: When the battery level is at maximum */
     278         [ #  # ]:          0 :       body = g_strdup (_("Battery Fully Charged"));
     279                 :          0 :       icon = g_themed_icon_new ("battery-full-charged-symbolic");
     280                 :            :     }
     281                 :            : 
     282                 :            :   /* Battery is no longer low or is charging */
     283   [ +  +  +  + ]:         15 :   else if (self->percentage > low || self->charging)
     284                 :            :     {
     285                 :         13 :       valent_device_plugin_hide_notification (VALENT_DEVICE_PLUGIN (self),
     286                 :            :                                               "battery-level");
     287                 :         13 :       return;
     288                 :            :     }
     289                 :            : 
     290                 :            :   /* Battery is now low */
     291   [ -  +  -  - ]:          2 :   else if (self->percentage <= low || threshold_event == 1)
     292                 :            :     {
     293                 :          2 :       int64_t total_minutes;
     294                 :          2 :       int minutes;
     295                 :          2 :       int hours;
     296                 :            : 
     297         [ +  - ]:          2 :       if (!g_settings_get_boolean (settings, "low-notification"))
     298                 :            :         return;
     299                 :            : 
     300                 :          2 :       total_minutes = floor (self->time_to_empty / 60);
     301                 :          2 :       minutes = total_minutes % 60;
     302                 :          2 :       hours = floor (total_minutes / 60);
     303                 :            : 
     304                 :            :       /* TRANSLATORS: This is <device name>: Battery Low */
     305                 :          2 :       title = g_strdup_printf (_("%s: Battery Low"), device_name);
     306                 :            :       /* TRANSLATORS: This is <percentage> (<hours>:<minutes> Remaining) */
     307                 :          2 :       body = g_strdup_printf (_("%g%% (%d∶%02d Remaining)"),
     308                 :            :                               self->percentage, hours, minutes);
     309                 :          2 :       icon = g_themed_icon_new ("battery-caution-symbolic");
     310                 :            :     }
     311                 :            : 
     312                 :          2 :   notification = g_notification_new (title);
     313                 :          2 :   g_notification_set_body (notification, body);
     314                 :          2 :   g_notification_set_icon (notification, icon);
     315                 :            : 
     316         [ +  - ]:          2 :   valent_device_plugin_show_notification (VALENT_DEVICE_PLUGIN (self),
     317                 :            :                                           "battery-level",
     318                 :            :                                           notification);
     319                 :            : }
     320                 :            : 
     321                 :            : static void
     322                 :         18 : valent_battery_plugin_handle_battery (ValentBatteryPlugin *self,
     323                 :            :                                       JsonNode            *packet)
     324                 :            : {
     325                 :         18 :   gboolean is_charging;
     326                 :         18 :   int64_t current_charge;
     327                 :         18 :   int64_t threshold_event;
     328                 :            : 
     329         [ +  - ]:         18 :   g_assert (VALENT_IS_BATTERY_PLUGIN (self));
     330         [ -  + ]:         18 :   g_assert (VALENT_IS_PACKET (packet));
     331                 :            : 
     332         [ -  + ]:         18 :   if (!valent_packet_get_boolean (packet, "isCharging", &is_charging))
     333                 :          0 :     is_charging = self->charging;
     334                 :            : 
     335         [ -  + ]:         18 :   if (!valent_packet_get_int (packet, "currentCharge", &current_charge))
     336                 :          0 :     current_charge = self->percentage;
     337                 :            : 
     338         [ -  + ]:         18 :   if (!valent_packet_get_int (packet, "thresholdEvent", &threshold_event))
     339                 :          0 :     threshold_event = 0;
     340                 :            : 
     341                 :            :   /* We get a lot of battery updates, so check if something changed */
     342   [ +  +  +  + ]:         24 :   if (self->charging == is_charging &&
     343         [ +  + ]:          6 :       G_APPROX_VALUE (self->percentage, current_charge, 0.1))
     344                 :          1 :     return;
     345                 :            : 
     346                 :            :   /* If `current_charge` is `-1`, either there is no battery or statistics are
     347                 :            :    * unavailable. Otherwise update the estimate before the instance properties
     348                 :            :    * so that the time/percentage deltas can be calculated. */
     349         [ +  + ]:         17 :   if (current_charge >= 0)
     350                 :         16 :     valent_battery_plugin_update_estimate (self, current_charge, is_charging);
     351                 :            : 
     352                 :         17 :   self->charging = is_charging;
     353   [ +  -  +  + ]:         17 :   self->percentage = CLAMP (current_charge, 0.0, 100.0);
     354                 :         17 :   self->is_present = current_charge >= 0;
     355                 :         17 :   self->icon_name = valent_battery_plugin_get_icon_name (self);
     356                 :            : 
     357                 :         17 :   valent_battery_plugin_update_gaction (self);
     358                 :         17 :   valent_battery_plugin_update_notification (self, threshold_event);
     359                 :            : }
     360                 :            : 
     361                 :            : static void
     362                 :          5 : valent_battery_plugin_request_state (ValentBatteryPlugin *self)
     363                 :            : {
     364                 :         10 :   g_autoptr (JsonBuilder) builder = NULL;
     365         [ -  + ]:          5 :   g_autoptr (JsonNode) packet = NULL;
     366                 :            : 
     367         [ +  - ]:          5 :   g_assert (VALENT_IS_BATTERY_PLUGIN (self));
     368                 :            : 
     369                 :          5 :   valent_packet_init (&builder, "kdeconnect.battery.request");
     370                 :          5 :   json_builder_set_member_name (builder, "request");
     371                 :          5 :   json_builder_add_boolean_value (builder, TRUE);
     372                 :          5 :   packet = valent_packet_end (&builder);
     373                 :            : 
     374         [ +  - ]:          5 :   valent_device_plugin_queue_packet (VALENT_DEVICE_PLUGIN (self), packet);
     375                 :          5 : }
     376                 :            : 
     377                 :            : /*
     378                 :            :  * GActions
     379                 :            :  */
     380                 :            : static void
     381                 :          0 : state_action (GSimpleAction *action,
     382                 :            :               GVariant      *parameter,
     383                 :            :               gpointer       user_data)
     384                 :            : {
     385                 :            :   // No-op to make the state read-only
     386                 :          0 : }
     387                 :            : 
     388                 :            : static const GActionEntry actions[] = {
     389                 :            :     {"state", NULL, NULL, "@a{sv} {}", state_action},
     390                 :            : };
     391                 :            : 
     392                 :            : /*
     393                 :            :  * ValentDevicePlugin
     394                 :            :  */
     395                 :            : static void
     396                 :         18 : valent_battery_plugin_update_state (ValentDevicePlugin *plugin,
     397                 :            :                                     ValentDeviceState   state)
     398                 :            : {
     399                 :         18 :   ValentBatteryPlugin *self = VALENT_BATTERY_PLUGIN (plugin);
     400                 :         18 :   gboolean available;
     401                 :            : 
     402         [ +  - ]:         18 :   g_assert (VALENT_IS_BATTERY_PLUGIN (self));
     403                 :            : 
     404                 :         18 :   available = (state & VALENT_DEVICE_STATE_CONNECTED) != 0 &&
     405                 :            :               (state & VALENT_DEVICE_STATE_PAIRED) != 0;
     406                 :            : 
     407         [ +  + ]:         18 :   if (available)
     408                 :            :     {
     409                 :          5 :       valent_battery_plugin_update_gaction (self);
     410                 :          5 :       valent_battery_plugin_watch_battery (self, TRUE);
     411                 :          5 :       valent_battery_plugin_request_state (self);
     412                 :            :     }
     413                 :            :   else
     414                 :            :     {
     415                 :         13 :       valent_extension_toggle_actions (VALENT_EXTENSION (plugin), available);
     416                 :         13 :       valent_battery_plugin_watch_battery (self, FALSE);
     417                 :            :     }
     418                 :         18 : }
     419                 :            : 
     420                 :            : static void
     421                 :         19 : valent_battery_plugin_handle_packet (ValentDevicePlugin *plugin,
     422                 :            :                                      const char         *type,
     423                 :            :                                      JsonNode           *packet)
     424                 :            : {
     425                 :         19 :   ValentBatteryPlugin *self = VALENT_BATTERY_PLUGIN (plugin);
     426                 :            : 
     427         [ +  - ]:         19 :   g_assert (VALENT_IS_BATTERY_PLUGIN (self));
     428         [ -  + ]:         19 :   g_assert (type != NULL);
     429         [ -  + ]:         19 :   g_assert (VALENT_IS_PACKET (packet));
     430                 :            : 
     431                 :            :   /* The remote battery state changed */
     432         [ +  + ]:         19 :   if (g_str_equal (type, "kdeconnect.battery"))
     433                 :         18 :     valent_battery_plugin_handle_battery (self, packet);
     434                 :            : 
     435                 :            :   /* A request for the local battery state */
     436         [ +  - ]:          1 :   else if (g_str_equal (type, "kdeconnect.battery.request"))
     437                 :          1 :     valent_battery_plugin_handle_battery_request (self, packet);
     438                 :            : 
     439                 :            :   else
     440                 :          0 :     g_assert_not_reached ();
     441                 :         19 : }
     442                 :            : 
     443                 :            : /*
     444                 :            :  * GObject
     445                 :            :  */
     446                 :            : static void
     447                 :          6 : valent_battery_plugin_constructed (GObject *object)
     448                 :            : {
     449                 :          6 :   ValentBatteryPlugin *self = VALENT_BATTERY_PLUGIN (object);
     450                 :            : 
     451                 :          6 :   g_action_map_add_action_entries (G_ACTION_MAP (object),
     452                 :            :                                    actions,
     453                 :            :                                    G_N_ELEMENTS (actions),
     454                 :            :                                    object);
     455                 :          6 :   valent_battery_plugin_update_gaction (self);
     456                 :            : 
     457                 :          6 :   G_OBJECT_CLASS (valent_battery_plugin_parent_class)->constructed (object);
     458                 :          6 : }
     459                 :            : 
     460                 :            : static void
     461                 :         12 : valent_battery_plugin_dispose (GObject *object)
     462                 :            : {
     463                 :         12 :   ValentBatteryPlugin *self = VALENT_BATTERY_PLUGIN (object);
     464                 :            : 
     465                 :         12 :   valent_battery_plugin_watch_battery (self, FALSE);
     466                 :            : 
     467                 :         12 :   G_OBJECT_CLASS (valent_battery_plugin_parent_class)->dispose (object);
     468                 :         12 : }
     469                 :            : 
     470                 :            : static void
     471                 :          3 : valent_battery_plugin_class_init (ValentBatteryPluginClass *klass)
     472                 :            : {
     473                 :          3 :   GObjectClass *object_class = G_OBJECT_CLASS (klass);
     474                 :          3 :   ValentDevicePluginClass *plugin_class = VALENT_DEVICE_PLUGIN_CLASS (klass);
     475                 :            : 
     476                 :          3 :   object_class->constructed = valent_battery_plugin_constructed;
     477                 :          3 :   object_class->dispose = valent_battery_plugin_dispose;
     478                 :            : 
     479                 :          3 :   plugin_class->handle_packet = valent_battery_plugin_handle_packet;
     480                 :          3 :   plugin_class->update_state = valent_battery_plugin_update_state;
     481                 :            : }
     482                 :            : 
     483                 :            : static void
     484                 :          6 : valent_battery_plugin_init (ValentBatteryPlugin *self)
     485                 :            : {
     486                 :          6 :   self->icon_name = "battery-missing-symbolic";
     487                 :          6 :   self->charge_rate = DEFAULT_CHARGE_RATE;
     488                 :          6 :   self->discharge_rate = DEFAULT_DISCHARGE_RATE;
     489                 :          6 : }
     490                 :            : 

Generated by: LCOV version 1.14