Add some error handling

yafi/yafi.py

@@ -1,6 +1,7 @@
 import sys
 import os
 import gi
+import traceback
 
 gi.require_version("Gtk", "4.0")
 gi.require_version("Adw", "1")
@@ -14,10 +15,31 @@ import cros_ec_python.exceptions as ec_exceptions
 class YAFI(Adw.Application):
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        self.connect("activate", self.on_activate)
         self.script_dir = os.path.dirname(os.path.abspath(__file__))
         self.no_support = []
-        self.cros_ec = get_cros_ec()
+
+        try:
+            self.cros_ec = get_cros_ec()
+
+            self.connect("activate", self.on_activate)
+        except Exception as e:
+            traceback.print_exc()
+
+            message = (
+                str(e) + "\n\n" + "This application only supports Framework Laptops.\n" +
+                "If you are using a Framework Laptop, there are additional troubleshooting steps in the README."
+            )
+
+            dialog = Adw.AlertDialog(heading="EC Initalisation Error", body=message)
+            dialog.add_response("exit", "Exit")
+            dialog.connect("response", lambda d, r: self.win.destroy())
+
+            self.connect(
+                "activate",
+                lambda app: self.minimal_activate(
+                    app, lambda: dialog.present(self.win)
+                ),
+            )
 
     def _change_page(self, builder, page):
         content = builder.get_object("content")
@@ -26,6 +48,7 @@ class YAFI(Adw.Application):
         content.append(page)
 
     def _update_thermals(self, fan_rpm, temp_items, fan_rpm_target):
+        # memmap reads should always be supported
         ec_fans = ec_commands.memmap.get_fans(self.cros_ec)
         fan_rpm.set_subtitle(f"{ec_fans[0]} RPM")
 
@@ -34,8 +57,21 @@ class YAFI(Adw.Application):
         for i in range(min(len(temp_items), len(ec_temp_sensors))):
             temp_items[i].set_subtitle(f"{ec_temp_sensors[i]}°C")
 
-        ec_target_rpm = ec_commands.pwm.pwm_get_fan_rpm(self.cros_ec)
+        # Check if this has already failed and skip if it has
-        fan_rpm_target.set_subtitle(f"{ec_target_rpm} RPM")
+        if not ec_commands.pwm.EC_CMD_PWM_GET_FAN_TARGET_RPM in self.no_support:
+            try:
+                ec_target_rpm = ec_commands.pwm.pwm_get_fan_rpm(self.cros_ec)
+                fan_rpm_target.set_subtitle(f"{ec_target_rpm} RPM")
+            except ec_exceptions.ECError as e:
+                # If the command is not supported, we can ignore it
+                if e.ec_status == ec_exceptions.EcStatus.EC_RES_INVALID_COMMAND:
+                    self.no_support.append(
+                        ec_commands.pwm.EC_CMD_PWM_GET_FAN_TARGET_RPM
+                    )
+                    fan_rpm_target.set_subtitle("")
+                else:
+                    # If it's another error, we should raise it
+                    raise e
 
         return self.current_page == 0
 
@@ -56,41 +92,71 @@ class YAFI(Adw.Application):
         fan_set_percent = thermals_builder.get_object("fan-set-percent")
         fan_percent_scale = thermals_builder.get_object("fan-percent-scale")
 
-        def handle_fan_mode(mode):
+        # Don't let the user change the fans if they can't get back to auto
-            match mode:
+        if not ec_commands.general.get_cmd_versions(
-                case 0:  # Auto
+            self.cros_ec, ec_commands.thermal.EC_CMD_THERMAL_AUTO_FAN_CTRL
-                    fan_set_rpm.set_visible(False)
+        ):
-                    fan_set_percent.set_visible(False)
-                    ec_commands.thermal.thermal_auto_fan_ctrl(self.cros_ec)
-                case 1:  # Percent
-                    fan_set_rpm.set_visible(False)
-                    fan_set_percent.set_visible(True)
-                case 2:  # RPM
-                    fan_set_rpm.set_visible(True)
-                    fan_set_percent.set_visible(False)
 
-        fan_mode.connect(
+            def handle_fan_mode(mode):
-            "notify::selected", lambda combo, _: handle_fan_mode(combo.get_selected())
+                match mode:
-        )
+                    case 0:  # Auto
+                        fan_set_rpm.set_visible(False)
+                        fan_set_percent.set_visible(False)
+                        ec_commands.thermal.thermal_auto_fan_ctrl(self.cros_ec)
+                    case 1:  # Percent
+                        fan_set_rpm.set_visible(False)
+                        fan_set_percent.set_visible(True)
+                    case 2:  # RPM
+                        fan_set_rpm.set_visible(True)
+                        fan_set_percent.set_visible(False)
 
-        def handle_fan_percent(scale):
+            fan_mode.connect(
-            percent = int(scale.get_value())
+                "notify::selected",
-            ec_commands.pwm.pwm_set_fan_duty(self.cros_ec, percent)
+                lambda combo, _: handle_fan_mode(combo.get_selected()),
-            fan_set_percent.set_subtitle(f"{percent} %")
+            )
 
-        fan_percent_scale.connect("value-changed", handle_fan_percent)
+            if ec_commands.general.get_cmd_versions(
+                self.cros_ec, ec_commands.pwm.EC_CMD_PWM_SET_FAN_DUTY
+            ):
 
-        def handle_fan_rpm(entry):
+                def handle_fan_percent(scale):
-            rpm = int(entry.get_text())
+                    percent = int(scale.get_value())
-            ec_commands.pwm.pwm_set_fan_rpm(self.cros_ec, rpm)
+                    ec_commands.pwm.pwm_set_fan_duty(self.cros_ec, percent)
+                    fan_set_percent.set_subtitle(f"{percent} %")
 
-        fan_set_rpm.connect("notify::text", lambda entry, _: handle_fan_rpm(entry))
+                fan_percent_scale.connect("value-changed", handle_fan_percent)
+            else:
+                fan_set_percent.set_sensitive(False)
+
+            if ec_commands.general.get_cmd_versions(
+                self.cros_ec, ec_commands.pwm.EC_CMD_PWM_SET_FAN_TARGET_RPM
+            ):
+
+                def handle_fan_rpm(entry):
+                    rpm = int(entry.get_text())
+                    ec_commands.pwm.pwm_set_fan_rpm(self.cros_ec, rpm)
+
+                fan_set_rpm.connect(
+                    "notify::text", lambda entry, _: handle_fan_rpm(entry)
+                )
+            else:
+                fan_set_rpm.set_sensitive(False)
 
         # Temperature sensors
         temperatures = thermals_builder.get_object("temperatures")
         temp_items = []
+        try:
+            ec_temp_sensors = ec_commands.thermal.get_temp_sensors(self.cros_ec)
+        except ec_exceptions.ECError as e:
+            if e.ec_status == ec_exceptions.EcStatus.EC_RES_INVALID_COMMAND:
+                # Generate some labels if the command is not supported
+                ec_temp_sensors = {}
+                temps = ec_commands.memmap.get_temps(self.cros_ec)
+                for i, temp in enumerate(temps):
+                    ec_temp_sensors[f"Sensor {i}"] = (temp, None)
+            else:
+                raise e
 
-        ec_temp_sensors = ec_commands.thermal.get_temp_sensors(self.cros_ec)
         for key, value in ec_temp_sensors.items():
             new_row = Adw.ActionRow(title=key, subtitle=f"{value[0]}°C")
             new_row.add_css_class("property")
@@ -118,96 +184,118 @@ class YAFI(Adw.Application):
         led_pwr = leds_builder.get_object("led-pwr")
         led_pwr_scale = leds_builder.get_object("led-pwr-scale")
 
-        def handle_led_pwr(scale):
+        try:
-            value = int(abs(scale.get_value() - 2))
-            ec_commands.framework_laptop.set_fp_led_level(self.cros_ec, value)
-            led_pwr.set_subtitle(["High", "Medium", "Low"][value])
 
-        current_fp_level = ec_commands.framework_laptop.get_fp_led_level(
+            def handle_led_pwr(scale):
-            self.cros_ec
+                value = int(abs(scale.get_value() - 2))
-        ).value
+                ec_commands.framework_laptop.set_fp_led_level(self.cros_ec, value)
-        led_pwr_scale.set_value(abs(current_fp_level - 2))
+                led_pwr.set_subtitle(["High", "Medium", "Low"][value])
-        led_pwr.set_subtitle(["High", "Medium", "Low"][current_fp_level])
+
-        led_pwr_scale.connect("value-changed", handle_led_pwr)
+            current_fp_level = ec_commands.framework_laptop.get_fp_led_level(
+                self.cros_ec
+            ).value
+            led_pwr_scale.set_value(abs(current_fp_level - 2))
+            led_pwr.set_subtitle(["High", "Medium", "Low"][current_fp_level])
+            led_pwr_scale.connect("value-changed", handle_led_pwr)
+        except ec_exceptions.ECError as e:
+            if e.ec_status == ec_exceptions.EcStatus.EC_RES_INVALID_COMMAND:
+                self.no_support.append(ec_commands.framework_laptop.EC_CMD_FP_LED_LEVEL)
+                led_pwr.set_visible(False)
+            else:
+                raise e
 
         # Keyboard backlight
         led_kbd = leds_builder.get_object("led-kbd")
         led_kbd_scale = leds_builder.get_object("led-kbd-scale")
 
-        def handle_led_kbd(scale):
+        if ec_commands.general.get_cmd_versions(
-            value = int(scale.get_value())
+            self.cros_ec, ec_commands.pwm.EC_CMD_PWM_SET_KEYBOARD_BACKLIGHT
-            ec_commands.pwm.pwm_set_keyboard_backlight(self.cros_ec, value)
+        ):
-            led_kbd.set_subtitle(f"{value} %")
 
-        current_kb_level = ec_commands.pwm.pwm_get_keyboard_backlight(self.cros_ec)[
+            def handle_led_kbd(scale):
-            "percent"
+                value = int(scale.get_value())
-        ]
+                ec_commands.pwm.pwm_set_keyboard_backlight(self.cros_ec, value)
-        led_kbd_scale.set_value(current_kb_level)
+                led_kbd.set_subtitle(f"{value} %")
-        led_kbd.set_subtitle(f"{current_kb_level} %")
-        led_kbd_scale.connect("value-changed", handle_led_kbd)
 
-        # Advanced: Power LED
+            current_kb_level = ec_commands.pwm.pwm_get_keyboard_backlight(self.cros_ec)[
-        led_pwr_colour = leds_builder.get_object("led-pwr-colour")
+                "percent"
-        led_pwr_colour_strings = led_pwr_colour.get_model()
+            ]
+            led_kbd_scale.set_value(current_kb_level)
+            led_kbd.set_subtitle(f"{current_kb_level} %")
+            led_kbd_scale.connect("value-changed", handle_led_kbd)
+        else:
+            led_kbd.set_visible(False)
 
-        all_colours = ["Red", "Green", "Blue", "Yellow", "White", "Amber"]
+        # Advanced options
+        if ec_commands.general.get_cmd_versions(
+            self.cros_ec, ec_commands.leds.EC_CMD_LED_CONTROL
+        ):
 
-        def add_colours(strings, led_id):
+            # Advanced: Power LED
-            supported_colours = ec_commands.leds.led_control_get_max_values(
+            led_pwr_colour = leds_builder.get_object("led-pwr-colour")
-                self.cros_ec, led_id
+            led_pwr_colour_strings = led_pwr_colour.get_model()
+
+            all_colours = ["Red", "Green", "Blue", "Yellow", "White", "Amber"]
+
+            def add_colours(strings, led_id):
+                supported_colours = ec_commands.leds.led_control_get_max_values(
+                    self.cros_ec, led_id
+                )
+                for i, colour in enumerate(all_colours):
+                    if supported_colours[i]:
+                        strings.append(colour)
+
+            add_colours(
+                led_pwr_colour_strings, ec_commands.leds.EcLedId.EC_LED_ID_POWER_LED
             )
-            for i, colour in enumerate(all_colours):
-                if supported_colours[i]:
-                    strings.append(colour)
 
-        add_colours(
+            def handle_led_colour(combobox, led_id):
-            led_pwr_colour_strings, ec_commands.leds.EcLedId.EC_LED_ID_POWER_LED
+                colour = combobox.get_selected() - 2
-        )
+                match colour:
+                    case -2:  # Auto
+                        ec_commands.leds.led_control_set_auto(self.cros_ec, led_id)
+                    case -1:  # Off
+                        ec_commands.leds.led_control(
+                            self.cros_ec,
+                            led_id,
+                            0,
+                            [0] * ec_commands.leds.EcLedColors.EC_LED_COLOR_COUNT.value,
+                        )
+                    case _:  # Colour
+                        colour_idx = all_colours.index(
+                            combobox.get_selected_item().get_string()
+                        )
+                        ec_commands.leds.led_control_set_color(
+                            self.cros_ec,
+                            led_id,
+                            100,
+                            ec_commands.leds.EcLedColors(colour_idx),
+                        )
 
-        def handle_led_colour(combobox, led_id):
+            led_pwr_colour.connect(
-            colour = combobox.get_selected() - 2
+                "notify::selected",
-            match colour:
+                lambda combo, _: handle_led_colour(
-                case -2:  # Auto
+                    combo, ec_commands.leds.EcLedId.EC_LED_ID_POWER_LED
-                    ec_commands.leds.led_control_set_auto(self.cros_ec, led_id)
+                ),
-                case -1:  # Off
+            )
-                    ec_commands.leds.led_control(
-                        self.cros_ec,
-                        led_id,
-                        0,
-                        [0] * ec_commands.leds.EcLedColors.EC_LED_COLOR_COUNT.value,
-                    )
-                case _:  # Colour
-                    colour_idx = all_colours.index(
-                        combobox.get_selected_item().get_string()
-                    )
-                    ec_commands.leds.led_control_set_color(
-                        self.cros_ec,
-                        led_id,
-                        100,
-                        ec_commands.leds.EcLedColors(colour_idx),
-                    )
 
-        led_pwr_colour.connect(
+            # Advanced: Charging LED
-            "notify::selected",
+            led_charge_colour = leds_builder.get_object("led-chg-colour")
-            lambda combo, _: handle_led_colour(
+            led_charge_colour_strings = led_charge_colour.get_model()
-                combo, ec_commands.leds.EcLedId.EC_LED_ID_POWER_LED
-            ),
-        )
 
-        # Advanced: Charging LED
+            add_colours(
-        led_charge_colour = leds_builder.get_object("led-chg-colour")
+                led_charge_colour_strings,
-        led_charge_colour_strings = led_charge_colour.get_model()
+                ec_commands.leds.EcLedId.EC_LED_ID_BATTERY_LED,
+            )
 
-        add_colours(
+            led_charge_colour.connect(
-            led_charge_colour_strings, ec_commands.leds.EcLedId.EC_LED_ID_BATTERY_LED
+                "notify::selected",
-        )
+                lambda combo, _: handle_led_colour(
-
+                    combo, ec_commands.leds.EcLedId.EC_LED_ID_BATTERY_LED
-        led_charge_colour.connect(
+                ),
-            "notify::selected",
+            )
-            lambda combo, _: handle_led_colour(
+        else:
-                combo, ec_commands.leds.EcLedId.EC_LED_ID_BATTERY_LED
+            leds_builder.get_object("led-advanced").set_visible(False)
-            ),
-        )
 
     def _format_timedelta(self, timedelta):
         days = f"{timedelta.days} days, " if timedelta.days else ""
@@ -216,15 +304,29 @@ class YAFI(Adw.Application):
         return days + f"{hours}:{minutes:02}:{seconds:02}"
 
     def _update_battery(self, bat_ext_stage, bat_ext_trigger_time, bat_ext_reset_time):
-        ec_extender = ec_commands.framework_laptop.get_battery_extender(self.cros_ec)
+        if ec_commands.framework_laptop.EC_CMD_BATTERY_EXTENDER in self.no_support:
+            return False
 
-        bat_ext_stage.set_subtitle(str(ec_extender["current_stage"]))
+        try:
-        bat_ext_trigger_time.set_subtitle(
+            ec_extender = ec_commands.framework_laptop.get_battery_extender(
-            self._format_timedelta(ec_extender["trigger_timedelta"])
+                self.cros_ec
-        )
+            )
-        bat_ext_reset_time.set_subtitle(
+
-            self._format_timedelta(ec_extender["reset_timedelta"])
+            bat_ext_stage.set_subtitle(str(ec_extender["current_stage"]))
-        )
+            bat_ext_trigger_time.set_subtitle(
+                self._format_timedelta(ec_extender["trigger_timedelta"])
+            )
+            bat_ext_reset_time.set_subtitle(
+                self._format_timedelta(ec_extender["reset_timedelta"])
+            )
+        except ec_exceptions.ECError as e:
+            if e.ec_status == ec_exceptions.EcStatus.EC_RES_INVALID_COMMAND:
+                self.no_support.append(
+                    ec_commands.framework_laptop.EC_CMD_BATTERY_EXTENDER
+                )
+                return False
+            else:
+                raise e
 
         return self.current_page == 2
 
@@ -247,54 +349,63 @@ class YAFI(Adw.Application):
         chg_limit_override = battery_builder.get_object("chg-limit-override")
         chg_limit_override_btn = battery_builder.get_object("chg-limit-override-btn")
 
-        ec_limit = ec_commands.framework_laptop.get_charge_limit(self.cros_ec)
+        try:
-        ec_limit_enabled = ec_limit != (0, 0)
+            ec_limit = ec_commands.framework_laptop.get_charge_limit(self.cros_ec)
-        chg_limit_enable.set_active(ec_limit_enabled)
+            ec_limit_enabled = ec_limit != (0, 0)
-        if ec_limit_enabled:
+            chg_limit_enable.set_active(ec_limit_enabled)
-            chg_limit_scale.set_value(ec_limit[0])
+            if ec_limit_enabled:
-            bat_limit_scale.set_value(ec_limit[1])
+                chg_limit_scale.set_value(ec_limit[0])
-            chg_limit.set_sensitive(True)
+                bat_limit_scale.set_value(ec_limit[1])
-            bat_limit.set_sensitive(True)
+                chg_limit.set_sensitive(True)
-            chg_limit_override.set_sensitive(True)
+                bat_limit.set_sensitive(True)
+                chg_limit_override.set_sensitive(True)
 
-        def handle_chg_limit_change(min, max):
+            def handle_chg_limit_change(min, max):
-            ec_commands.framework_laptop.set_charge_limit(
+                ec_commands.framework_laptop.set_charge_limit(
-                self.cros_ec, int(min), int(max)
+                    self.cros_ec, int(min), int(max)
+                )
+
+            def handle_chg_limit_enable(switch):
+                active = switch.get_active()
+                if active:
+                    handle_chg_limit_change(
+                        chg_limit_scale.get_value(), bat_limit_scale.get_value()
+                    )
+                else:
+                    ec_commands.framework_laptop.disable_charge_limit(self.cros_ec)
+
+                chg_limit.set_sensitive(active)
+                bat_limit.set_sensitive(active)
+                chg_limit_override.set_sensitive(active)
+
+            chg_limit_enable.connect(
+                "notify::active", lambda switch, _: handle_chg_limit_enable(switch)
+            )
+            chg_limit_scale.connect(
+                "value-changed",
+                lambda scale: handle_chg_limit_change(
+                    scale.get_value(), bat_limit_scale.get_value()
+                ),
+            )
+            bat_limit_scale.connect(
+                "value-changed",
+                lambda scale: handle_chg_limit_change(
+                    chg_limit_scale.get_value(), scale.get_value()
+                ),
             )
 
-        def handle_chg_limit_enable(switch):
+            chg_limit_override_btn.connect(
-            active = switch.get_active()
+                "clicked",
-            if active:
+                lambda _: ec_commands.framework_laptop.override_charge_limit(
-                handle_chg_limit_change(
+                    self.cros_ec
-                    chg_limit_scale.get_value(), bat_limit_scale.get_value()
+                ),
-                )
+            )
+        except ec_exceptions.ECError as e:
+            if e.ec_status == ec_exceptions.EcStatus.EC_RES_INVALID_COMMAND:
+                self.no_support.append(ec_commands.framework_laptop.EC_CMD_CHARGE_LIMIT)
+                chg_limit_enable.set_sensitive(False)
             else:
-                ec_commands.framework_laptop.disable_charge_limit(self.cros_ec)
+                raise e
-
-            chg_limit.set_sensitive(active)
-            bat_limit.set_sensitive(active)
-            chg_limit_override.set_sensitive(active)
-
-        chg_limit_enable.connect(
-            "notify::active", lambda switch, _: handle_chg_limit_enable(switch)
-        )
-        chg_limit_scale.connect(
-            "value-changed",
-            lambda scale: handle_chg_limit_change(
-                scale.get_value(), bat_limit_scale.get_value()
-            ),
-        )
-        bat_limit_scale.connect(
-            "value-changed",
-            lambda scale: handle_chg_limit_change(
-                chg_limit_scale.get_value(), scale.get_value()
-            ),
-        )
-
-        chg_limit_override_btn.connect(
-            "clicked",
-            lambda _: ec_commands.framework_laptop.override_charge_limit(self.cros_ec),
-        )
 
         # Battery Extender
         bat_ext_group = battery_builder.get_object("bat-ext-group")
@@ -305,59 +416,70 @@ class YAFI(Adw.Application):
         bat_ext_trigger = battery_builder.get_object("bat-ext-trigger")
         bat_ext_reset = battery_builder.get_object("bat-ext-reset")
 
-        ec_extender = ec_commands.framework_laptop.get_battery_extender(self.cros_ec)
+        try:
-        bat_ext_enable.set_active(not ec_extender["disable"])
+            ec_extender = ec_commands.framework_laptop.get_battery_extender(
-        bat_ext_stage.set_sensitive(not ec_extender["disable"])
+                self.cros_ec
-        bat_ext_trigger_time.set_sensitive(not ec_extender["disable"])
-        bat_ext_reset_time.set_sensitive(not ec_extender["disable"])
-        bat_ext_trigger.set_sensitive(not ec_extender["disable"])
-        bat_ext_reset.set_sensitive(not ec_extender["disable"])
-
-        bat_ext_stage.set_subtitle(str(ec_extender["current_stage"]))
-        bat_ext_trigger_time.set_subtitle(
-            self._format_timedelta(ec_extender["trigger_timedelta"])
-        )
-        bat_ext_reset_time.set_subtitle(
-            self._format_timedelta(ec_extender["reset_timedelta"])
-        )
-        bat_ext_trigger.set_value(ec_extender["trigger_days"])
-        bat_ext_reset.set_value(ec_extender["reset_minutes"])
-
-        def handle_extender_enable(switch):
-            active = switch.get_active()
-            ec_commands.framework_laptop.set_battery_extender(
-                self.cros_ec,
-                not active,
-                int(bat_ext_trigger.get_value()),
-                int(bat_ext_reset.get_value()),
             )
-            bat_ext_stage.set_sensitive(active)
+            bat_ext_enable.set_active(not ec_extender["disable"])
-            bat_ext_trigger_time.set_sensitive(active)
+            bat_ext_stage.set_sensitive(not ec_extender["disable"])
-            bat_ext_reset_time.set_sensitive(active)
+            bat_ext_trigger_time.set_sensitive(not ec_extender["disable"])
-            bat_ext_trigger.set_sensitive(active)
+            bat_ext_reset_time.set_sensitive(not ec_extender["disable"])
-            bat_ext_reset.set_sensitive(active)
+            bat_ext_trigger.set_sensitive(not ec_extender["disable"])
+            bat_ext_reset.set_sensitive(not ec_extender["disable"])
 
-        bat_ext_enable.connect(
+            bat_ext_stage.set_subtitle(str(ec_extender["current_stage"]))
-            "notify::active", lambda switch, _: handle_extender_enable(switch)
+            bat_ext_trigger_time.set_subtitle(
-        )
+                self._format_timedelta(ec_extender["trigger_timedelta"])
-        bat_ext_trigger.connect(
+            )
-            "notify::value",
+            bat_ext_reset_time.set_subtitle(
-            lambda scale, _: ec_commands.framework_laptop.set_battery_extender(
+                self._format_timedelta(ec_extender["reset_timedelta"])
-                self.cros_ec,
+            )
-                not bat_ext_enable.get_active(),
+            bat_ext_trigger.set_value(ec_extender["trigger_days"])
-                int(scale.get_value()),
+            bat_ext_reset.set_value(ec_extender["reset_minutes"])
-                int(bat_ext_reset.get_value()),
+
-            ),
+            def handle_extender_enable(switch):
-        )
+                active = switch.get_active()
-        bat_ext_reset.connect(
+                ec_commands.framework_laptop.set_battery_extender(
-            "notify::value",
+                    self.cros_ec,
-            lambda scale, _: ec_commands.framework_laptop.set_battery_extender(
+                    not active,
-                self.cros_ec,
+                    int(bat_ext_trigger.get_value()),
-                not bat_ext_enable.get_active(),
+                    int(bat_ext_reset.get_value()),
-                int(bat_ext_trigger.get_value()),
+                )
-                int(scale.get_value()),
+                bat_ext_stage.set_sensitive(active)
-            ),
+                bat_ext_trigger_time.set_sensitive(active)
-        )
+                bat_ext_reset_time.set_sensitive(active)
+                bat_ext_trigger.set_sensitive(active)
+                bat_ext_reset.set_sensitive(active)
+
+            bat_ext_enable.connect(
+                "notify::active", lambda switch, _: handle_extender_enable(switch)
+            )
+            bat_ext_trigger.connect(
+                "notify::value",
+                lambda scale, _: ec_commands.framework_laptop.set_battery_extender(
+                    self.cros_ec,
+                    not bat_ext_enable.get_active(),
+                    int(scale.get_value()),
+                    int(bat_ext_reset.get_value()),
+                ),
+            )
+            bat_ext_reset.connect(
+                "notify::value",
+                lambda scale, _: ec_commands.framework_laptop.set_battery_extender(
+                    self.cros_ec,
+                    not bat_ext_enable.get_active(),
+                    int(bat_ext_trigger.get_value()),
+                    int(scale.get_value()),
+                ),
+            )
+        except ec_exceptions.ECError as e:
+            if e.ec_status == ec_exceptions.EcStatus.EC_RES_INVALID_COMMAND:
+                self.no_support.append(
+                    ec_commands.framework_laptop.EC_CMD_BATTERY_EXTENDER
+                )
+                bat_ext_group.set_visible(False)
+            else:
+                raise e
 
         # Schedule _update_battery to run every second
         GLib.timeout_add_seconds(
@@ -390,7 +512,7 @@ class YAFI(Adw.Application):
 
                 success = True
             except ec_exceptions.ECError as e:
-                if e.status == ec_exceptions.EcStatus.EC_RES_INVALID_COMMAND.value:
+                if e.ec_status == ec_exceptions.EcStatus.EC_RES_INVALID_COMMAND:
                     self.no_support.append(
                         ec_commands.framework_laptop.EC_CMD_CHASSIS_INTRUSION
                     )
@@ -417,7 +539,7 @@ class YAFI(Adw.Application):
 
                 success = True
             except ec_exceptions.ECError as e:
-                if e.status == ec_exceptions.EcStatus.EC_RES_INVALID_COMMAND.value:
+                if e.ec_status == ec_exceptions.EcStatus.EC_RES_INVALID_COMMAND:
                     self.no_support.append(
                         ec_commands.framework_laptop.EC_CMD_PRIVACY_SWITCHES_CHECK_MODE
                     )
@@ -482,11 +604,23 @@ class YAFI(Adw.Application):
 
         about.present()
 
-    def on_activate(self, app):
+    def minimal_activate(self, app, callback):
-        # Create a Builder
         builder = Gtk.Builder()
         builder.add_from_file(os.path.join(self.script_dir, "ui/yafi.ui"))
 
+        self.win = builder.get_object("root")
+        self.win.set_application(self)
+        self.win.present()
+
+        callback()
+
+    def on_activate(self, app):
+        builder = Gtk.Builder()
+        builder.add_from_file(os.path.join(self.script_dir, "ui/yafi.ui"))
+
+        self.win = builder.get_object("root")
+        self.win.set_application(self)
+
         self.current_page = 0
         self._thermals_page(builder)
 
@@ -513,9 +647,6 @@ class YAFI(Adw.Application):
 
         navbar.connect("row-activated", lambda box, row: switch_page(row.get_index()))
 
-        # Obtain and show the main window
-        self.win = builder.get_object("root")
-        self.win.set_application(self)
         self.win.present()