ptrcnull/bat-alert
1
0
Fork 1
Code Issues Pull requests Projects Releases 1 Wiki Activity

Compare commits

base: ptrcnull:master
Branches Tags
ptrcnull:master
ptrcnull:test
meithecatte:master
meithecatte:test
ptrcnull:v0.2.0
ptrcnull:v0.1.0
meithecatte:v0.1.0
..
compare: meithecatte:master
Branches Tags
meithecatte:master
meithecatte:test
ptrcnull:master
ptrcnull:test
meithecatte:v0.1.0
ptrcnull:v0.2.0
ptrcnull:v0.1.0

No commits in common. "master" and "master" have entirely different histories.
master ... master

6 changed files with 69 additions and 190 deletions
Show stats Expand all files Collapse all files

18
.drone.yml Normal file
View file

@ -0,0 +1,18 @@
---
kind: pipeline
steps:
- name: build
image: "golang:alpine"
commands:
- go build
- name: release
image: plugins/gitea-release
settings:
api_key:
from_secret: gitea_api_key
base_url: https://git.ddd.rip
files: bat-alert
when:
event: tag

2
.gitignore vendored
View file

@ -1,2 +0,0 @@
zig-cache/
zig-out/

76
build.zig
View file

@ -1,76 +0,0 @@
const std = @import("std");
// Although this function looks imperative, note that its job is to
// declaratively construct a build graph that will be executed by an external
// runner.
pub fn build(b: *std.Build) void {
// Standard target options allows the person running `zig build` to choose
// what target to build for. Here we do not override the defaults, which
// means any target is allowed, and the default is native. Other options
// for restricting supported target set are available.
const target = b.standardTargetOptions(.{});
// Standard optimization options allow the person running `zig build` to select
// between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
// set a preferred release mode, allowing the user to decide how to optimize.
const optimize = b.standardOptimizeOption(.{});
const exe = b.addExecutable(.{
.name = "bat-alert",
// In this case the main source file is merely a path, however, in more
// complicated build scripts, this could be a generated file.
.root_source_file = .{ .path = "src/main.zig" },
.target = target,
.optimize = optimize,
});
exe.linkLibC();
exe.addIncludePath(.{ .cwd_relative = "/usr/include/glib-2.0" });
exe.addIncludePath(.{ .cwd_relative = "/usr/lib/glib-2.0/include" });
exe.addIncludePath(.{ .cwd_relative = "/usr/include/gdk-pixbuf-2.0" });
exe.linkSystemLibrary("notify");
// This declares intent for the executable to be installed into the
// standard location when the user invokes the "install" step (the default
// step when running `zig build`).
b.installArtifact(exe);
// This *creates* a Run step in the build graph, to be executed when another
// step is evaluated that depends on it. The next line below will establish
// such a dependency.
const run_cmd = b.addRunArtifact(exe);
// By making the run step depend on the install step, it will be run from the
// installation directory rather than directly from within the cache directory.
// This is not necessary, however, if the application depends on other installed
// files, this ensures they will be present and in the expected location.
run_cmd.step.dependOn(b.getInstallStep());
// This allows the user to pass arguments to the application in the build
// command itself, like this: `zig build run -- arg1 arg2 etc`
if (b.args) |args| {
run_cmd.addArgs(args);
}
// This creates a build step. It will be visible in the `zig build --help` menu,
// and can be selected like this: `zig build run`
// This will evaluate the `run` step rather than the default, which is "install".
const run_step = b.step("run", "Run the app");
run_step.dependOn(&run_cmd.step);
// Creates a step for unit testing. This only builds the test executable
// but does not run it.
const unit_tests = b.addTest(.{
.root_source_file = .{ .path = "src/main.zig" },
.target = target,
.optimize = optimize,
});
const run_unit_tests = b.addRunArtifact(unit_tests);
// Similar to creating the run step earlier, this exposes a `test` step to
// the `zig build --help` menu, providing a way for the user to request
// running the unit tests.
const test_step = b.step("test", "Run unit tests");
test_step.dependOn(&run_unit_tests.step);
}

3
go.mod Normal file
View file

@ -0,0 +1,3 @@
module git.ddd.rip/ptrcnull/bat-alert
go 1.16

48
main.go Normal file
View file

@ -0,0 +1,48 @@
package main
import (
"flag"
"log"
"os"
"os/exec"
"strconv"
"strings"
"time"
)
func notify(msg string) {
cmd := exec.Command("notify-send", "-t", "5000", "-u", "critical", "bat-alert", msg)
err := cmd.Run()
if err != nil {
log.Println(err)
}
}
var targetFlag = flag.Int("target", 15, "when to send the alert")
func main() {
flag.Parse()
sent := false
for {
capacity, err := os.ReadFile("/sys/class/power_supply/BAT0/capacity")
if err != nil {
notify("error: " + err.Error())
}
numCap, err := strconv.Atoi(strings.Trim(string(capacity), "\n"))
if err != nil {
notify("error: " + err.Error())
}
if numCap <= *targetFlag {
if !sent {
sent = true
notify("battery running low!")
}
} else {
sent = false
}
time.Sleep(time.Second * 10)
}
}

112
src/main.zig
View file

@ -1,112 +0,0 @@
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);
}
}