system76-oled 0.1.0

Control brightness on OLED displays
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use env_logger::Env;
use inotify::{
    Inotify,
    WatchMask,
};
use log::{debug, info, trace};
use std::{fs, process};
use std::fmt::Write;
use std::io::{Read, Seek, SeekFrom};

fn main() {
    env_logger::from_env(Env::default().default_filter_or("info")).init();

    let vendor = fs::read_to_string("/sys/class/dmi/id/sys_vendor")
        .unwrap_or(String::new());
    let vendor = vendor.trim();
    let model = fs::read_to_string("/sys/class/dmi/id/product_version")
        .unwrap_or(String::new());
    let model = model.trim();

    let output_opt = match (vendor, model) {
        ("System76", "addw1") => Some("eDP-1"),
        _ => None,
    };

    let output = if let Some(output) = output_opt {
        info!("Vendor '{}' Model '{}' has OLED display on '{}'", vendor, model, output);
        output
    } else {
        debug!("Vendor '{}' Model '{}' does not have OLED display", vendor, model);
        process::exit(0);
    };

    let mut inotify = Inotify::init()
        .expect("failed to initialize inotify");

    let requested_path = "/sys/class/backlight/intel_backlight/brightness";

    let requested_watch = inotify.add_watch(requested_path, WatchMask::MODIFY)
        .expect("failed to watch requested brightness");

    let mut requested_file = fs::File::open(requested_path)
        .expect("failed to open requested brightness");

    let max_path = "/sys/class/backlight/intel_backlight/max_brightness";

    let max_watch = inotify.add_watch(max_path, WatchMask::MODIFY)
        .expect("failed to watch max brightness");

    let mut max_file = fs::File::open(max_path)
        .expect("failed to open max brightness");

    let mut requested_update = true;
    let mut requested_str = String::with_capacity(256);
    let mut requested = 0;
    let mut max_update = true;
    let mut max_str = String::with_capacity(256);
    let mut max = 0;
    let mut current_str = String::with_capacity(256);
    let mut current = !0;

    loop {
        if requested_update {
            requested_str.clear();
            requested_file.seek(SeekFrom::Start(0))
                .expect("failed to seek requested brightness");
            requested_file.read_to_string(&mut requested_str)
                .expect("failed to read requested brightness");
            requested = requested_str.trim().parse::<u64>()
                .expect("failed to parse requested brightness");
            requested_update = false;
            debug!("requested {}", requested);
        }

        if max_update {
            max_str.clear();
            max_file.seek(SeekFrom::Start(0))
                .expect("failed to seek max brightness");
            max_file.read_to_string(&mut max_str)
                .expect("failed to read max brightness");
            max = max_str.trim().parse::<u64>()
                .expect("failed to parse max brightness");
            max_update = false;
            debug!("max {}", requested);
        }

        let next = requested * 100 / max;
        while current != next {
            current = next;
            /* Smooth transition (may require use of xlib for performance)
            if current == !0 {
                current = next;
            } else if current < next {
                current += 1;
            } else if current > next {
                current -= 1;
            }
            */

            debug!("current {}%", current);

            current_str.clear();
            write!(current_str, "{}", current as f64 / 100.0)
                .expect("failed to serialize current brightness");

            process::Command::new("xrandr")
                .arg("--output").arg(output)
                .arg("--brightness").arg(&current_str)
                .status()
                .expect("failed to run xrandr");
        }

        let mut buffer = [0; 1024];
        let events = inotify.read_events_blocking(&mut buffer)
            .expect("failed to read events");

        for event in events {
            trace!("event {:?}", event);
            if event.wd == requested_watch {
                requested_update = true;
            }
            if event.wd == max_watch {
                max_update = true;
            }
        }
    }
}