battery: add notifications

applets/battery/__init__.py

@@ -18,10 +18,12 @@ along with this program. If not, see <https://www.gnu.org/licenses/>.

                                
                                
                                
                            
                                
                                    
                                        
                                            18  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            19  
                                            from __future__ import annotations
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            20  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        21 +
                                        import threading
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        22 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            23  
                                            import panorama_panel
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            24  
                                            import locale
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            25  
                                            from pathlib import Path
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        24 -
                                        from pydbus import SystemBus
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        26 +
                                        from pydbus import SystemBus, SessionBus
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            27  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            28  
                                            import gi
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            29  
                                            gi.require_version("Gtk", "4.0")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -65,6 +67,8 @@ class BatteryMonitor(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            67  
                                                        config = {}
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            68  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            69  
                                                    self.bus = SystemBus()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        70 +
                                                self.session_bus = SessionBus()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        71 +
                                                self.notification_service = None
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            72  
                                                    self.upower = self.bus.get("org.freedesktop.UPower")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            73  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            74  
                                                    self.button = Gtk.MenuButton()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -72,10 +76,20 @@ class BatteryMonitor(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            76  
                                                    self.button.set_child(self.icon)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            77  
                                                    self.append(self.button)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            78  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        79 +
                                                self.low_threshold = config.get("low_threshold", 15/100)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        80 +
                                                self.low_notification = None
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        81 +
                                                self.critical_threshold = config.get("critical_threshold", 5/100)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        82 +
                                                self.critical_notification = None
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        83 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        84 +
                                                self.popover = Gtk.Popover()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        85 +
                                                self.popover_content = Gtk.ListBox()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        86 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            87  
                                                    self.update_batteries()
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            88  
                                                    GLib.timeout_add_seconds(10, self.update_batteries)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            89  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            90  
                                                def update_batteries(self):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        91 +
                                                self.popover_content.remove_all()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        92 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            93  
                                                    total_energy = max_energy = 0
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            94  
                                                    any_charging = False
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            95  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        

@@ -91,18 +105,78 @@ class BatteryMonitor(panorama_panel.Applet):

                                
                                
                                
                            
                                
                                    
                                        
                                            105  
                                                            if device.State == 1:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            106  
                                                                any_charging = True
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            107  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        108 +
                                                if not max_energy:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        109 +
                                                    return False
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        110 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            111  
                                                    print(total_energy, max_energy)
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            112  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            113  
                                                    self.button.set_tooltip_text(f"{locale.format_string("%d", total_energy / max_energy * 1000)}‰")
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            114  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            115  
                                                    self.icon.set_from_icon_name(get_battery_icon(total_energy / max_energy, any_charging))
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            116  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        117 +
                                                GLib.idle_add(self.do_notifications, total_energy, max_energy)
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        118 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            119  
                                                    return True
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            120  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        121 +
                                            def do_notifications(self, total_energy, max_energy):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        122 +
                                                if self.session_bus.get("org.freedesktop.Notifications"):
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        123 +
                                                    self.notification_service = self.session_bus.get("org.freedesktop.Notifications")
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        124 +
                                                else:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        125 +
                                                    return
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        126 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        127 +
                                                # This uses threading to make sure it doesn't hang while waiting to deliver the
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        128 +
                                                # notification
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        129 +
                                                if total_energy / max_energy < self.low_threshold:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        130 +
                                                    if not self.low_notification:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        131 +
                                                        def send_notification():
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        132 +
                                                            self.low_notification = self.notification_service.Notify(
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        133 +
                                                                _("Battery"),
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        134 +
                                                                self.low_notification or self.critical_notification or 0,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        135 +
                                                                "battery-low",
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        136 +
                                                                _("The energy in the battery is low."),
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        137 +
                                                                "",
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        138 +
                                                                [],
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        139 +
                                                                {},
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        140 +
                                                                -1
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        141 +
                                                            )
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        142 +
                                                        threading.Thread(target=send_notification, daemon=True).start()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        143 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        144 +
                                                elif self.low_notification:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        145 +
                                                    threading.Thread(
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        146 +
                                                        target=lambda: self.notification_service.CloseNotification(self.low_notification),
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        147 +
                                                        daemon=True
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        148 +
                                                    ).start()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        149 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        150 +
                                                    self.low_notification = None
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        151 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        152 +
                                                if total_energy / max_energy < self.critical_threshold:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        153 +
                                                    if not self.critical_notification:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        154 +
                                                        def send_notification():
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        155 +
                                                            self.critical_notification = self.notification_service.Notify(
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        156 +
                                                                _("Battery"),
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        157 +
                                                                self.low_notification or self.critical_notification or 0,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        158 +
                                                                "battery-empty",
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        159 +
                                                                _("The energy in the battery is very low; the device will shut down soon."),
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        160 +
                                                                "",
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        161 +
                                                                [],
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        162 +
                                                                {},
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        163 +
                                                                -1
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        164 +
                                                            )
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        165 +
                                                        threading.Thread(target=send_notification, daemon=True).start()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        166 +
                                                elif self.critical_notification:
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        167 +
                                                    threading.Thread(
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        168 +
                                                        target=lambda: self.notification_service.CloseNotification(self.critical_notification),
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        169 +
                                                        daemon=True
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        170 +
                                                    ).start()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        171 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        172 +
                                                    self.critical_notification = None
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        173 +
                                        
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            174  
                                                def get_config(self):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            175  
                                                    return {
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            176  
                                                        "icon_size": self.icon.get_pixel_size(),
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        177 +
                                                    "low_threshold": self.low_threshold,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        178 +
                                                    "critical_threshold": self.critical_threshold,
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            179  
                                                    }
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            180  
                                            
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            181  
                                                def shutdown(self, app):
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        108 -
                                                self.publishing.unpublish()
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        182 +
                                                return
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                            
                                

config.yaml

@@ -60,6 +60,8 @@ panels:

                                
                                
                                
                            
                                
                                    
                                        
                                            60  
                                                right:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            61  
                                                - BatteryMonitor:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            62  
                                                    icon_size: 24
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        63 +
                                                low_threshold: 0.15
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        64 +
                                                critical_threshold: 0.05
                                        
                                        
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            65  
                                                - Volume:
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            66  
                                                    percentage_reveal: 1000
                                        
                                        
                                            
                                            
                                            
                                            
                                        
                                    
                                
                                
                                
                            
                                
                                    
                                        
                                            67  
                                                    popdown_after_manual: 2000