113 lines
3.8 KiB
Zig
113 lines
3.8 KiB
Zig
const std = @import("std");
|
|
const c = @cImport({
|
|
@cInclude("libnotify/notify.h");
|
|
});
|
|
|
|
pub const std_options = struct {
|
|
pub const log_level = .info;
|
|
};
|
|
|
|
const NOTIFICATION_TITLE: [:0]const u8 = "bat-alert";
|
|
const NOTIFICATION_BODY: [:0]const u8 = "battery running low!";
|
|
|
|
const ParseMode = enum { none, target, battery };
|
|
|
|
pub fn main() !void {
|
|
if (c.notify_init("bat-alert") == c.FALSE) {
|
|
std.log.err("notify_init failed", .{});
|
|
std.process.exit(1);
|
|
}
|
|
|
|
var target: u8 = 15;
|
|
var battery: []const u8 = "BAT0";
|
|
|
|
var argsIter = std.process.args();
|
|
|
|
var parse_mode = ParseMode.none;
|
|
while (argsIter.next()) |arg| {
|
|
switch (parse_mode) {
|
|
ParseMode.none => {
|
|
if (std.mem.eql(u8, arg, "--help")) {
|
|
const stdout = std.io.getStdOut().writer();
|
|
try stdout.print(
|
|
\\Usage: bat-alert [options]
|
|
\\
|
|
\\Options:
|
|
\\ -t, --target NUM Target battery level (default: 15)
|
|
\\ --battery NAME Battery name (default: BAT0)
|
|
\\
|
|
, .{});
|
|
std.process.exit(0);
|
|
}
|
|
if (std.mem.eql(u8, arg, "--target") or std.mem.eql(u8, arg, "-t")) {
|
|
parse_mode = ParseMode.target;
|
|
}
|
|
if (std.mem.eql(u8, arg, "--battery")) {
|
|
parse_mode = ParseMode.battery;
|
|
}
|
|
},
|
|
ParseMode.battery => {
|
|
battery = arg;
|
|
parse_mode = ParseMode.none;
|
|
},
|
|
ParseMode.target => {
|
|
const parsedTarget = std.fmt.parseInt(u8, arg, 10) catch {
|
|
std.log.err("cannot parse target '{s}' as int", .{arg});
|
|
std.process.exit(1);
|
|
};
|
|
target = parsedTarget;
|
|
parse_mode = ParseMode.none;
|
|
},
|
|
}
|
|
}
|
|
if (parse_mode != ParseMode.none) {
|
|
std.log.err("option requires an argument: --{s}", .{@tagName(parse_mode)});
|
|
std.process.exit(1);
|
|
}
|
|
|
|
var sent = false;
|
|
var batBuf: [256]u8 = undefined;
|
|
var capBuf: [8]u8 = undefined;
|
|
|
|
const batteryPath = try std.fmt.bufPrint(&batBuf, "/sys/class/power_supply/{s}/capacity", .{battery});
|
|
|
|
while (true) {
|
|
const capacityFile = std.fs.openFileAbsolute(batteryPath, .{}) catch |err| {
|
|
std.log.err("open {s}: {}", .{ batteryPath, err });
|
|
std.process.exit(1);
|
|
};
|
|
_ = try capacityFile.reader().readAll(&capBuf);
|
|
capacityFile.close();
|
|
var splat = std.mem.splitScalar(u8, &capBuf, '\n');
|
|
|
|
// std.log.info("battery: {s}", .{splat.first()});
|
|
|
|
const capacity = try std.fmt.parseInt(u8, splat.first(), 10);
|
|
// std.log.info("battery (but parsed): {}", .{capacity});
|
|
|
|
if (capacity <= target) {
|
|
if (!sent) {
|
|
sent = true;
|
|
// _ = try std.process.Child.exec(.{
|
|
// .allocator = allocator,
|
|
// .argv = &[_][]const u8{ "notify-send", "-t", "5000", "-u", "critical", NOTIFICATION_TITLE, NOTIFICATION_BODY },
|
|
// });
|
|
|
|
const notif = c.notify_notification_new(NOTIFICATION_TITLE, NOTIFICATION_BODY, null);
|
|
var g_err: [*c]c.GError = null;
|
|
const ret = c.notify_notification_show(notif, &g_err);
|
|
if (ret == c.FALSE) {
|
|
std.log.err("failed to send a notification: {s}", .{g_err.*.message});
|
|
}
|
|
c.g_object_unref(c.G_OBJECT(notif));
|
|
|
|
std.log.info("[NOTIFY] battery running low!", .{});
|
|
}
|
|
} else {
|
|
sent = false;
|
|
}
|
|
|
|
std.time.sleep(10 * 1e9);
|
|
}
|
|
}
|