Implement the wlr-output-power-management protocol

Related to #108, #856

This protocol allows external programs (e.g. wlopm) to control and query
the output power state (on/off).

In the current implementation, when the client sends a
`set_mode` request, the handler calls `activate_monitors()` or
`deactivate_monitors()` to set that state for all monitors. This
is probably simpler than adding full support for per-output power
management, and is good enough for the most common use cases like idle
screensavers.

The `output_power.mode` event is now emitted by `activate_monitors()`
and `deactivate_monitors()` when the state changes. A bit of a rewrite
was needed because the tty backend tries to activate monitors on resume,
but previously it wasn't calling `activate_monitors()` because it is
unable to provide a reference to the `Backend` that wraps it. I worked
around this by adding a second method that does not take a backend
parameter, instead assuming that the backend will take care of calling
itself.

Author: agausmann

src/backend/tty.rs

@@ -711,8 +711,11 @@ impl Tty {
                 self.refresh_ipc_outputs(niri);
 
                 niri.notify_activity();
-                niri.monitors_active = true;
+                niri.idle_notifier_state.notify_activity(&niri.seat);
+
                 self.set_monitors_active(true);
+                niri.activate_monitors_without_backend();
+
                 niri.queue_redraw_all();
             }
         }

src/handlers/mod.rs

@@ -82,6 +82,9 @@ use crate::protocols::foreign_toplevel::{
 use crate::protocols::gamma_control::{GammaControlHandler, GammaControlManagerState};
 use crate::protocols::mutter_x11_interop::MutterX11InteropHandler;
 use crate::protocols::output_management::{OutputManagementHandler, OutputManagementManagerState};
+use crate::protocols::output_power_management::{
+    self, OutputPowerManagementHandler, OutputPowerManagementManagerState,
+};
 use crate::protocols::screencopy::{Screencopy, ScreencopyHandler, ScreencopyManagerState};
 use crate::protocols::virtual_pointer::{
     VirtualPointerAxisEvent, VirtualPointerButtonEvent, VirtualPointerHandler,
@@ -90,8 +93,8 @@ use crate::protocols::virtual_pointer::{
 };
 use crate::utils::{output_size, send_scale_transform};
 use crate::{
-    delegate_ext_workspace, delegate_foreign_toplevel, delegate_gamma_control,
-    delegate_mutter_x11_interop, delegate_output_management, delegate_screencopy,
+    delegate_foreign_toplevel, delegate_gamma_control,delegate_ext_workspace,
+    delegate_mutter_x11_interop, delegate_output_management, delegate_output_power_management, delegate_screencopy,
     delegate_virtual_pointer,
 };
 
@@ -841,6 +844,34 @@ impl OutputManagementHandler for State {
 }
 delegate_output_management!(State);
 
+impl OutputPowerManagementHandler for State {
+    fn output_power_manager_state(&mut self) -> &mut OutputPowerManagementManagerState {
+        &mut self.niri.output_power_management_state
+    }
+
+    fn get_output_power_mode(&mut self, output: &Output) -> output_power_management::Mode {
+        // todo: per-output power management
+        let _ = output;
+
+        self.niri.monitors_active.into()
+    }
+
+    fn set_output_power_mode(&mut self, output: &Output, mode: output_power_management::Mode) {
+        // todo: per-output power management
+        let _ = output;
+
+        match mode {
+            output_power_management::Mode::Off => {
+                self.niri.deactivate_monitors(&mut self.backend);
+            }
+            output_power_management::Mode::On => {
+                self.niri.activate_monitors(&mut self.backend);
+            }
+        }
+    }
+}
+delegate_output_power_management!(State);
+
 impl MutterX11InteropHandler for State {}
 delegate_mutter_x11_interop!(State);
 

src/niri.rs

@@ -148,6 +148,7 @@ use crate::protocols::foreign_toplevel::{self, ForeignToplevelManagerState};
 use crate::protocols::gamma_control::GammaControlManagerState;
 use crate::protocols::mutter_x11_interop::MutterX11InteropManagerState;
 use crate::protocols::output_management::OutputManagementManagerState;
+use crate::protocols::output_power_management::{self, OutputPowerManagementManagerState};
 use crate::protocols::screencopy::{Screencopy, ScreencopyBuffer, ScreencopyManagerState};
 use crate::protocols::virtual_pointer::VirtualPointerManagerState;
 use crate::pw_utils::{Cast, PipeWire};
@@ -278,6 +279,7 @@ pub struct Niri {
     pub ext_workspace_state: ExtWorkspaceManagerState,
     pub screencopy_state: ScreencopyManagerState,
     pub output_management_state: OutputManagementManagerState,
+    pub output_power_management_state: OutputPowerManagementManagerState,
     pub viewporter_state: ViewporterState,
     pub xdg_foreign_state: XdgForeignState,
     pub shm_state: ShmState,
@@ -2525,6 +2527,10 @@ impl Niri {
         let mut output_management_state =
             OutputManagementManagerState::new::<State, _>(&display_handle, client_is_unrestricted);
         output_management_state.on_config_changed(config_.outputs.clone());
+        let output_power_management_state = OutputPowerManagementManagerState::new::<State, _>(
+            &display_handle,
+            client_is_unrestricted,
+        );
         let screencopy_state =
             ScreencopyManagerState::new::<State, _>(&display_handle, client_is_unrestricted);
         let viewporter_state = ViewporterState::new::<State>(&display_handle);
@@ -2718,6 +2724,7 @@ impl Niri {
             foreign_toplevel_state,
             ext_workspace_state,
             output_management_state,
+            output_power_management_state,
             screencopy_state,
             viewporter_state,
             xdg_foreign_state,
@@ -3216,15 +3223,41 @@ impl Niri {
 
         self.monitors_active = false;
         backend.set_monitors_active(false);
+        for output in self.global_space.outputs() {
+            self.output_power_management_state
+                .output_power_mode_changed(output, output_power_management::Mode::Off);
+        }
     }
 
     pub fn activate_monitors(&mut self, backend: &mut Backend) {
         if self.monitors_active {
             return;
         }
+        backend.set_monitors_active(true);
+        self.activate_monitors_without_backend();
+    }
+
+    /// Note: This is intended to only be directly used by the backend module,
+    /// when the backend would want to call `activate_monitors()` but is unable
+    /// to provide a reference to the whole `Backend` type.
+    ///
+    /// The backend needs to call its own `set_monitors_active(true)` before
+    /// calling this.
+    ///
+    /// One possible long-term solution: The type of the backend argument could
+    /// be turned into a trait bound, where the trait is implemented by both the
+    /// top-level `Backend` and its inner variant types.
+    pub fn activate_monitors_without_backend(&mut self) {
+        if self.monitors_active {
+            return;
+        }
 
         self.monitors_active = true;
-        backend.set_monitors_active(true);
+
+        for output in self.global_space.outputs() {
+            self.output_power_management_state
+                .output_power_mode_changed(output, output_power_management::Mode::On);
+        }
 
         self.queue_redraw_all();
     }

src/protocols/mod.rs

@@ -3,6 +3,7 @@ pub mod foreign_toplevel;
 pub mod gamma_control;
 pub mod mutter_x11_interop;
 pub mod output_management;
+pub mod output_power_management;
 pub mod screencopy;
 pub mod virtual_pointer;
 

src/protocols/output_power_management.rs

@@ -0,0 +1,234 @@
+use std::collections::HashMap;
+
+use smithay::{
+    output::Output,
+    reexports::{
+        wayland_protocols_wlr::output_power_management::v1::server::{
+            zwlr_output_power_manager_v1, zwlr_output_power_v1,
+        },
+        wayland_server::{
+            Client, DataInit, Dispatch, DisplayHandle, GlobalDispatch, New, Resource,
+        },
+    },
+};
+use zwlr_output_power_manager_v1::ZwlrOutputPowerManagerV1;
+use zwlr_output_power_v1::ZwlrOutputPowerV1;
+
+const VERSION: u32 = 1;
+
+#[derive(Clone, Copy)]
+pub enum Mode {
+    Off,
+    On,
+}
+
+impl From<bool> for Mode {
+    fn from(value: bool) -> Self {
+        match value {
+            false => Self::Off,
+            true => Self::On,
+        }
+    }
+}
+
+impl From<zwlr_output_power_v1::Mode> for Mode {
+    fn from(value: zwlr_output_power_v1::Mode) -> Self {
+        match value {
+            zwlr_output_power_v1::Mode::Off => Self::Off,
+            zwlr_output_power_v1::Mode::On => Self::On,
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl From<Mode> for zwlr_output_power_v1::Mode {
+    fn from(value: Mode) -> Self {
+        match value {
+            Mode::Off => Self::Off,
+            Mode::On => Self::On,
+        }
+    }
+}
+
+pub struct OutputPowerManagerGlobalData {
+    filter: Box<dyn for<'c> Fn(&'c Client) -> bool + Send + Sync>,
+}
+
+pub trait OutputPowerManagementHandler {
+    fn output_power_manager_state(&mut self) -> &mut OutputPowerManagementManagerState;
+    fn get_output_power_mode(&mut self, output: &Output) -> Mode;
+    fn set_output_power_mode(&mut self, output: &Output, mode: Mode);
+}
+
+pub struct OutputPowerManagementManagerState {
+    // Active controls only. Failed ones are removed.
+    output_powers: HashMap<Output, Vec<ZwlrOutputPowerV1>>,
+}
+
+pub struct OutputPowerState {}
+
+impl OutputPowerManagementManagerState {
+    pub fn new<D, F>(display: &DisplayHandle, filter: F) -> Self
+    where
+        D: GlobalDispatch<ZwlrOutputPowerManagerV1, OutputPowerManagerGlobalData>,
+        D: Dispatch<ZwlrOutputPowerManagerV1, ()>,
+        D: Dispatch<ZwlrOutputPowerV1, OutputPowerState>,
+        D: OutputPowerManagementHandler,
+        D: 'static,
+        F: for<'c> Fn(&'c Client) -> bool + Send + Sync + 'static,
+    {
+        let global_data = OutputPowerManagerGlobalData {
+            filter: Box::new(filter),
+        };
+        display.create_global::<D, ZwlrOutputPowerManagerV1, _>(VERSION, global_data);
+        Self {
+            output_powers: HashMap::new(),
+        }
+    }
+
+    pub fn output_removed(&mut self, output: &Output) {
+        if let Some(list) = self.output_powers.remove(output) {
+                           for num in list {
+                        num.failed();
+                    }     
+        }
+    }
+
+    pub fn output_power_mode_changed(&mut self, output: &Output, mode: Mode) {
+        match self.output_powers.get_mut(output) {
+                Some(list) => {
+                    for num in list {
+                        num.mode(mode.into());
+                    }
+                }
+                None => {
+                }
+            }
+    }
+}
+
+impl<D> GlobalDispatch<ZwlrOutputPowerManagerV1, OutputPowerManagerGlobalData, D>
+    for OutputPowerManagementManagerState
+where
+    D: GlobalDispatch<ZwlrOutputPowerManagerV1, OutputPowerManagerGlobalData>,
+    D: Dispatch<ZwlrOutputPowerManagerV1, ()>,
+    D: 'static,
+{
+    fn bind(
+        _state: &mut D,
+        _handle: &DisplayHandle,
+        _client: &Client,
+        manager: New<ZwlrOutputPowerManagerV1>,
+        _global_data: &OutputPowerManagerGlobalData,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        data_init.init(manager, ());
+    }
+
+    fn can_view(client: Client, global_data: &OutputPowerManagerGlobalData) -> bool {
+        (global_data.filter)(&client)
+    }
+}
+
+impl<D> Dispatch<ZwlrOutputPowerManagerV1, (), D> for OutputPowerManagementManagerState
+where
+    D: Dispatch<ZwlrOutputPowerManagerV1, ()>,
+    D: Dispatch<ZwlrOutputPowerV1, OutputPowerState>,
+    D: OutputPowerManagementHandler,
+    D: 'static,
+{
+    fn request(
+        state: &mut D,
+        _client: &Client,
+        _resource: &ZwlrOutputPowerManagerV1,
+        request: <ZwlrOutputPowerManagerV1 as Resource>::Request,
+        _data: &(),
+        _dhandle: &DisplayHandle,
+        data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            zwlr_output_power_manager_v1::Request::GetOutputPower { id, output } => {
+                let zwlr_output_power = data_init.init(id, OutputPowerState {});
+                if let Some(output) = Output::from_resource(&output) {
+                    state.output_power_manager_state().output_powers.entry(output.clone()).or_insert_with(Vec::new).push(zwlr_output_power.clone());
+                    zwlr_output_power.mode(state.get_output_power_mode(&output).into());
+                    return ;
+                }
+
+                // Output not found,
+                // or output power instance already exists
+                zwlr_output_power.failed();
+            }
+            zwlr_output_power_manager_v1::Request::Destroy => (),
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl<D> Dispatch<ZwlrOutputPowerV1, OutputPowerState, D> for OutputPowerManagementManagerState
+where
+    D: Dispatch<ZwlrOutputPowerV1, OutputPowerState>,
+    D: OutputPowerManagementHandler,
+    D: 'static,
+{
+    fn request(
+        state: &mut D,
+        _client: &Client,
+        resource: &ZwlrOutputPowerV1,
+        request: <ZwlrOutputPowerV1 as Resource>::Request,
+        _data: &OutputPowerState,
+        _dhandle: &DisplayHandle,
+        _data_init: &mut DataInit<'_, D>,
+    ) {
+        match request {
+            zwlr_output_power_v1::Request::SetMode { mode } => {
+                let output_powers = &mut state.output_power_manager_state().output_powers;
+                let Some((output, _)) = output_powers.iter().find(|(_, x)| x.contains( resource)) else {
+                    return;
+                };
+                let output = output.clone();
+
+                if let Ok(mode) = mode.into_result() {
+                    // note: if set_output_power_mode becomes fallible, this should
+                    // fail the resource; see gamma_control for an example of how to
+                    // implement that.
+                    state.set_output_power_mode(&output, mode.into());
+                } else {
+                    resource.failed();
+                }
+            }
+            zwlr_output_power_v1::Request::Destroy => (),
+            _ => unreachable!(),
+        }
+    }
+
+    fn destroyed(
+        state: &mut D,
+        _client: wayland_backend::server::ClientId,
+        resource: &ZwlrOutputPowerV1,
+        _data: &OutputPowerState,
+    ) {
+        let output_powers = &mut state.output_power_manager_state().output_powers;
+        let Some((output, _)) = output_powers.iter().find(|(_, x)| x.contains( resource)) else {
+            return;
+        };
+        output_powers.remove(&output.clone());
+    }
+}
+
+#[macro_export]
+macro_rules! delegate_output_power_management {
+    ($(@<$( $lt:tt $( : $clt:tt $(+ $dlt:tt )* )? ),+>)? $ty: ty) => {
+        smithay::reexports::wayland_server::delegate_global_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::output_power_management::v1::server::zwlr_output_power_manager_v1::ZwlrOutputPowerManagerV1: $crate::protocols::output_power_management::OutputPowerManagerGlobalData
+        ] => $crate::protocols::output_power_management::OutputPowerManagementManagerState);
+
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::output_power_management::v1::server::zwlr_output_power_manager_v1::ZwlrOutputPowerManagerV1: ()
+        ] => $crate::protocols::output_power_management::OutputPowerManagementManagerState);
+
+        smithay::reexports::wayland_server::delegate_dispatch!($(@< $( $lt $( : $clt $(+ $dlt )* )? ),+ >)? $ty: [
+            smithay::reexports::wayland_protocols_wlr::output_power_management::v1::server::zwlr_output_power_v1::ZwlrOutputPowerV1:  $crate::protocols::output_power_management::OutputPowerState
+        ] => $crate::protocols::output_power_management::OutputPowerManagementManagerState);
+    };
+}