wayle-brightness 0.1.2

Backlight control for internal displays
Documentation 
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

pub(crate) mod hotplug;
pub(crate) mod logind;
pub(crate) mod sysfs;
pub(crate) mod types;

use tokio::task::JoinHandle;
use tokio_util::sync::CancellationToken;
use tracing::{debug, info};

use self::types::{BrightnessEvent, Command, CommandReceiver, EventSender};
use crate::{Error, types::BacklightInfo};

pub(crate) fn start(
    initial_devices: Vec<BacklightInfo>,
    mut command_rx: CommandReceiver,
    event_tx: EventSender,
    token: CancellationToken,
) -> JoinHandle<Result<(), Error>> {
    tokio::spawn(async move {
        let logind_connection = logind::connect().await;

        info!(
            count = initial_devices.len(),
            "backlight devices discovered"
        );

        for device in &initial_devices {
            debug!(
                name = %device.name,
                backlight_type = ?device.backlight_type,
                brightness = device.brightness,
                max = device.max_brightness,
                "backlight device found"
            );

            let _ = event_tx.send(BrightnessEvent::DeviceAdded(device.clone()));
        }

        let _hotplug_handle = hotplug::spawn(event_tx.clone(), token.child_token());

        loop {
            tokio::select! {
                _ = token.cancelled() => {
                    info!("brightness backend stopping");
                    return Ok(());
                }

                Some(command) = command_rx.recv() => {
                    match command {
                        Command::SetBrightness { name, value, responder } => {
                            let result = logind::set_brightness(
                                &logind_connection,
                                &name,
                                value,
                            ).await;

                            let _ = responder.send(result);
                        }
                    }
                }
            }
        }
    })
}