stevee

Battery.zig (5059B)

---

 const std = @import("std");
 
 const udev = @import("udev");
 
 const Module = @import("../Modules.zig").Module;
 const Event = @import("../Loop.zig").Event;
 const render = @import("../render.zig");
 const utils = @import("../utils.zig");
 const Battery = @This();
 
 const state = &@import("root").state;
 
 context: *udev.Udev,
 fd: std.posix.fd_t,
 devices: DeviceList,
 
 const Device = struct {
     name: []const u8,
     status: []const u8,
     capacity: u8,
 };
 
 const DeviceList = std.ArrayList(Device);
 
 pub fn init() !Battery {
     const tfd = tfd: {
         const fd = try std.posix.timerfd_create(
             std.os.linux.TIMERFD_CLOCK.MONOTONIC,
             .{ .CLOEXEC = true },
         );
         const interval: std.os.linux.itimerspec = .{
             .it_interval = .{ .sec = 10, .nsec = 0 },
             .it_value = .{ .sec = 10, .nsec = 0 },
         };
         try std.posix.timerfd_settime(@intCast(fd), .{}, &interval, null);
         break :tfd @as(std.posix.fd_t, @intCast(fd));
     };
 
     const context = try udev.Udev.new();
 
     var devices = DeviceList.init(state.gpa);
     try updateDevices(state.gpa, context, &devices);
 
     return Battery{
         .context = context,
         .fd = tfd,
         .devices = devices,
     };
 }
 
 pub fn deinit(self: *Battery) void {
     _ = self.context.unref();
     for (self.devices.items) |*device| {
         state.gpa.free(device.name);
         state.gpa.free(device.status);
     }
     self.devices.deinit();
 }
 
 pub fn print(self: *Battery, writer: anytype) !void {
     try updateDevices(state.gpa, self.context, &self.devices);
     const device = self.devices.items[0];
 
     var icon: []const u8 = "❓";
     if (std.mem.eql(u8, device.status, "Discharging")) {
         icon = "󰁹";
     } else if (std.mem.eql(u8, device.status, "Charging")) {
         icon = "󰂄";
     } else if (std.mem.eql(u8, device.status, "Full")) {
         icon = "⚡";
     }
 
     try std.fmt.format(writer, "{s} {d}%", .{ icon, device.capacity });
 }
 
 pub fn refresh(self: *Battery) !void {
     var expirations = std.mem.zeroes([8]u8);
     _ = try std.posix.read(self.fd, &expirations);
 
     for (state.wayland.monitors.items) |monitor| {
         if (monitor.bar) |bar| {
             if (bar.configured) {
                 render.renderClock(bar) catch continue;
                 render.renderModules(bar) catch continue;
                 bar.clock.surface.commit();
                 bar.modules.surface.commit();
                 bar.background.surface.commit();
             }
         }
     }
 }
 
 fn updateDevices(
     gpa: std.mem.Allocator,
     context: *udev.Udev,
     devices: *DeviceList,
 ) !void {
     const enumerate = try udev.Enumerate.new(context);
     defer _ = enumerate.unref();
 
     try enumerate.addMatchSubsystem("power_supply");
     try enumerate.addMatchSysattr("type", "Battery");
     try enumerate.scanDevices();
 
     const entries = enumerate.getListEntry();
 
     var maybe_entry = entries;
     while (maybe_entry) |entry| : (maybe_entry = entry.getNext()) {
         const path = entry.getName();
         const device = try udev.Device.newFromSyspath(context, path);
         try updateOrAppend(gpa, devices, device);
     }
 }
 
 fn updateOrAppend(
     gpa: std.mem.Allocator,
     devices: *DeviceList,
     dev: *udev.Device,
 ) !void {
     const name = dev.getSysname() catch return;
     const status = dev.getSysattrValue("status") catch return;
     const capacity = getCapacity(dev) catch return;
 
     const device = blk: {
         for (devices.items) |*device| {
             if (std.mem.eql(u8, device.name, name)) {
                 gpa.free(device.status);
                 break :blk device;
             }
         } else {
             const device = try devices.addOne();
             device.name = try gpa.dupe(u8, name);
             break :blk device;
         }
     };
 
     device.status = try gpa.dupe(u8, status);
     device.capacity = capacity;
 }
 
 fn getCapacity(dev: *udev.Device) !u8 {
     const capacity_str = dev.getSysattrValue("capacity") catch {
         return computeCapacityFromCharge(dev) catch {
             return computeCapacityFromEnergy(dev);
         };
     };
 
     const capacity = try std.fmt.parseInt(u8, capacity_str, 10);
     return capacity;
 }
 
 fn computeCapacityFromEnergy(dev: *udev.Device) !u8 {
     const energy_str = try dev.getSysattrValue("energy_now");
     const energy_full_str = try dev.getSysattrValue("energy_full");
 
     const energy = try std.fmt.parseFloat(f64, energy_str);
     const energy_full = try std.fmt.parseFloat(f64, energy_full_str);
 
     const capacity = energy * 100.0 / energy_full;
     return @as(u8, @intFromFloat(@round(capacity)));
 }
 
 fn computeCapacityFromCharge(dev: *udev.Device) !u8 {
     const charge_str = try dev.getSysattrValue("charge_now");
     const charge_full_str = try dev.getSysattrValue("charge_full");
 
     const charge = try std.fmt.parseFloat(f64, charge_str);
     const charge_full = try std.fmt.parseFloat(f64, charge_full_str);
 
     const capacity = charge * 100.0 / charge_full;
     return @as(u8, @intFromFloat(@round(capacity)));
 }