Merge pull request #351 from mahkoh/jorth/idle-grace-period

idle: add a grace period

Author: mahkoh

jay-config/src/_private/client.rs

@@ -893,6 +893,10 @@ impl Client {
         self.send(&ClientMessage::SetIdle { timeout })
     }
 
+    pub fn set_idle_grace_period(&self, period: Duration) {
+        self.send(&ClientMessage::SetIdleGracePeriod { period })
+    }
+
     pub fn set_explicit_sync_enabled(&self, enabled: bool) {
         self.send(&ClientMessage::SetExplicitSyncEnabled { enabled })
     }

jay-config/src/_private/ipc.rs

@@ -527,6 +527,9 @@ pub enum ClientMessage<'a> {
     SetXScalingMode {
         mode: XScalingMode,
     },
+    SetIdleGracePeriod {
+        period: Duration,
+    },
 }
 
 #[derive(Serialize, Deserialize, Debug)]

jay-config/src/lib.rs

@@ -224,10 +224,24 @@ pub fn workspaces() -> Vec<Workspace> {
 /// Configures the idle timeout.
 ///
 /// `None` disables the timeout.
+///
+/// The default is 10 minutes.
 pub fn set_idle(timeout: Option<Duration>) {
     get!().set_idle(timeout.unwrap_or_default())
 }
 
+/// Configures the idle grace period.
+///
+/// The grace period starts after the idle timeout expires. During the grace period, the
+/// screen goes black but the displays are not yet disabled and the idle callback (set
+/// with [`on_idle`]) is not yet called. This is a purely visual effect to inform the user
+/// that the machine will soon go idle.
+///
+/// The default is 5 seconds.
+pub fn set_idle_grace_period(timeout: Duration) {
+    get!().set_idle_grace_period(timeout)
+}
+
 /// Enables or disables explicit sync.
 ///
 /// Calling this after the compositor has started has no effect.

release-notes.md

@@ -5,6 +5,9 @@
 - Implement wl-fixes.
 - Implement ei_touchscreen v2.
 - Implement idle-notification v2.
+- Add an idle grace period. During the grace period, the screen goes black but is neither
+  disabled nor locked. This is similar to how android handles going idle. The default is
+  5 seconds.
 
 # 1.7.0 (2024-10-25)
 

src/backends/metal/present.rs

@@ -504,6 +504,7 @@ impl MetalConnector {
             true,
             render_hw_cursor,
             node.has_fullscreen(),
+            true,
             node.global.persistent.transform.get(),
             Some(&self.state.damage_visualizer),
         );

src/cli.rs

@@ -17,7 +17,7 @@ mod xwayland;
 use {
     crate::{
         cli::{
-            damage_tracking::DamageTrackingArgs, input::InputArgs, randr::RandrArgs,
+            damage_tracking::DamageTrackingArgs, idle::IdleCmd, input::InputArgs, randr::RandrArgs,
             xwayland::XwaylandArgs,
         },
         compositor::start_compositor,
@@ -101,38 +101,6 @@ pub struct RunPrivilegedArgs {
     pub program: Vec<String>,
 }
 
-#[derive(Subcommand, Debug)]
-pub enum IdleCmd {
-    /// Print the idle status.
-    Status,
-    /// Set the idle interval.
-    Set(IdleSetArgs),
-}
-
-impl Default for IdleCmd {
-    fn default() -> Self {
-        Self::Status
-    }
-}
-
-#[derive(Args, Debug)]
-pub struct IdleSetArgs {
-    /// The interval of inactivity after which to disable the screens.
-    ///
-    /// This can be either a number in minutes and seconds or the keyword `disabled` to
-    /// disable the screensaver.
-    ///
-    /// Minutes and seconds can be specified in any of the following formats:
-    ///
-    /// * 1m
-    /// * 1m5s
-    /// * 1m 5s
-    /// * 1min 5sec
-    /// * 1 minute 5 seconds
-    #[clap(verbatim_doc_comment, required = true)]
-    pub interval: Vec<String>,
-}
-
 #[derive(ValueEnum, Debug, Copy, Clone, Hash, Default, PartialEq)]
 pub enum ScreenshotFormat {
     /// The PNG image format.

src/cli/idle.rs

@@ -1,13 +1,60 @@
 use {
     crate::{
-        cli::{duration::parse_duration, GlobalArgs, IdleArgs, IdleCmd, IdleSetArgs},
+        cli::{duration::parse_duration, GlobalArgs, IdleArgs},
         tools::tool_client::{with_tool_client, Handle, ToolClient},
-        utils::stack::Stack,
+        utils::{debug_fn::debug_fn, stack::Stack},
         wire::{jay_compositor, jay_idle, JayIdleId, WlSurfaceId},
     },
+    clap::{Args, Subcommand},
     std::{cell::Cell, rc::Rc},
 };
 
+#[derive(Subcommand, Debug)]
+pub enum IdleCmd {
+    /// Print the idle status.
+    Status,
+    /// Set the idle interval.
+    Set(IdleSetArgs),
+    /// Set the idle grace period.
+    SetGracePeriod(IdleSetGracePeriodArgs),
+}
+
+impl Default for IdleCmd {
+    fn default() -> Self {
+        Self::Status
+    }
+}
+
+#[derive(Args, Debug)]
+pub struct IdleSetArgs {
+    /// The interval of inactivity after which to disable the screens.
+    ///
+    /// This can be either a number in minutes and seconds or the keyword `disabled` to
+    /// disable the screensaver.
+    ///
+    /// Minutes and seconds can be specified in any of the following formats:
+    ///
+    /// * 1m
+    /// * 1m5s
+    /// * 1m 5s
+    /// * 1min 5sec
+    /// * 1 minute 5 seconds
+    #[clap(verbatim_doc_comment, required = true)]
+    pub interval: Vec<String>,
+}
+
+#[derive(Args, Debug)]
+pub struct IdleSetGracePeriodArgs {
+    /// The grace period after the idle timeout expires.
+    ///
+    /// During this period, after the idle timeout expires, the screen only goes black
+    /// but is not yet disabled or locked.
+    ///
+    /// This uses the same formatting options as the idle timeout itself.
+    #[clap(verbatim_doc_comment, required = true)]
+    pub period: Vec<String>,
+}
+
 pub fn main(global: GlobalArgs, args: IdleArgs) {
     with_tool_client(global.log_level.into(), |tc| async move {
         let idle = Idle { tc: tc.clone() };
@@ -31,16 +78,21 @@ impl Idle {
         match args.command.unwrap_or_default() {
             IdleCmd::Status => self.status(idle).await,
             IdleCmd::Set(args) => self.set(idle, args).await,
+            IdleCmd::SetGracePeriod(args) => self.set_grace_period(idle, args).await,
         }
     }
 
     async fn status(self, idle: JayIdleId) {
         let tc = &self.tc;
         tc.send(jay_idle::GetStatus { self_id: idle });
-        let interval = Rc::new(Cell::new(0u64));
-        jay_idle::Interval::handle(tc, idle, interval.clone(), |iv, msg| {
+        let timeout = Rc::new(Cell::new(0u64));
+        jay_idle::Interval::handle(tc, idle, timeout.clone(), |iv, msg| {
             iv.set(msg.interval);
         });
+        let grace = Rc::new(Cell::new(0u64));
+        jay_idle::GracePeriod::handle(tc, idle, grace.clone(), |iv, msg| {
+            iv.set(msg.period);
+        });
         struct Inhibitor {
             surface: WlSurfaceId,
             _client_id: u64,
@@ -57,26 +109,31 @@ impl Idle {
             });
         });
         tc.round_trip().await;
-        let minutes = interval.get() / 60;
-        let seconds = interval.get() % 60;
-        print!("Interval:");
-        if minutes == 0 && seconds == 0 {
-            print!(" disabled");
-        } else {
-            if minutes > 0 {
-                print!(" {} minute", minutes);
-                if minutes > 1 {
-                    print!("s");
+        let interval = |iv: u64| {
+            debug_fn(move |f| {
+                let minutes = iv / 60;
+                let seconds = iv % 60;
+                if minutes == 0 && seconds == 0 {
+                    write!(f, " disabled")?;
+                } else {
+                    if minutes > 0 {
+                        write!(f, " {} minute", minutes)?;
+                        if minutes > 1 {
+                            write!(f, "s")?;
+                        }
+                    }
+                    if seconds > 0 {
+                        write!(f, " {} second", seconds)?;
+                        if seconds > 1 {
+                            write!(f, "s")?;
+                        }
+                    }
                 }
-            }
-            if seconds > 0 {
-                print!(" {} second", seconds);
-                if seconds > 1 {
-                    print!("s");
-                }
-            }
-        }
-        println!();
+                Ok(())
+            })
+        };
+        println!("Interval:{}", interval(timeout.get()));
+        println!("Grace period:{}", interval(grace.get()));
         let mut inhibitors = inhibitors.take();
         inhibitors.sort_by_key(|i| i.pid);
         inhibitors.sort_by_key(|i| i.surface);
@@ -93,15 +150,27 @@ impl Idle {
 
     async fn set(self, idle: JayIdleId, args: IdleSetArgs) {
         let tc = &self.tc;
-        let interval = if args.interval.len() == 1 && args.interval[0] == "disabled" {
-            0
-        } else {
-            parse_duration(&args.interval).as_secs() as u64
-        };
         tc.send(jay_idle::SetInterval {
             self_id: idle,
-            interval,
+            interval: parse_idle_time(&args.interval),
+        });
+        tc.round_trip().await;
+    }
+
+    async fn set_grace_period(self, idle: JayIdleId, args: IdleSetGracePeriodArgs) {
+        let tc = &self.tc;
+        tc.send(jay_idle::SetGracePeriod {
+            self_id: idle,
+            period: parse_idle_time(&args.period),
         });
         tc.round_trip().await;
     }
 }
+
+fn parse_idle_time(time: &[String]) -> u64 {
+    if time.len() == 1 && time[0] == "disabled" {
+        0
+    } else {
+        parse_duration(time).as_secs() as u64
+    }
+}

src/compositor.rs

@@ -200,11 +200,13 @@ fn start_compositor2(
             input: Default::default(),
             change: Default::default(),
             timeout: Cell::new(Duration::from_secs(10 * 60)),
+            grace_period: Cell::new(Duration::from_secs(5)),
             timeout_changed: Default::default(),
             inhibitors: Default::default(),
             inhibitors_changed: Default::default(),
             inhibited_idle_notifications: Default::default(),
             backend_idle: Cell::new(true),
+            in_grace_period: Cell::new(false),
         },
         run_args,
         xwayland: XWaylandState {

src/config/handler.rs

@@ -919,6 +919,10 @@ impl ConfigProxyHandler {
         self.state.idle.set_timeout(timeout);
     }
 
+    fn handle_set_idle_grace_period(&self, period: Duration) {
+        self.state.idle.set_grace_period(period);
+    }
+
     fn handle_set_explicit_sync_enabled(&self, enabled: bool) {
         self.state.explicit_sync_enabled.set(enabled);
     }
@@ -1980,6 +1984,9 @@ impl ConfigProxyHandler {
             ClientMessage::SetXScalingMode { mode } => self
                 .handle_set_x_scaling_mode(mode)
                 .wrn("set_x_scaling_mode")?,
+            ClientMessage::SetIdleGracePeriod { period } => {
+                self.handle_set_idle_grace_period(period)
+            }
         }
         Ok(())
     }

src/gfx_api.rs

@@ -371,6 +371,7 @@ impl dyn GfxFramebuffer {
         render_cursor: bool,
         render_hardware_cursor: bool,
         black_background: bool,
+        fill_black_in_grace_period: bool,
         transform: Transform,
         visualizer: Option<&DamageVisualizer>,
     ) -> GfxRenderPass {
@@ -383,6 +384,7 @@ impl dyn GfxFramebuffer {
             render_cursor,
             render_hardware_cursor,
             black_background,
+            fill_black_in_grace_period,
             transform,
             visualizer,
         )
@@ -406,6 +408,7 @@ impl dyn GfxFramebuffer {
         cursor_rect: Option<Rect>,
         scale: Scale,
         render_hardware_cursor: bool,
+        fill_black_in_grace_period: bool,
     ) -> Result<Option<SyncFile>, GfxError> {
         self.render_node(
             acquire_sync,
@@ -417,6 +420,7 @@ impl dyn GfxFramebuffer {
             true,
             render_hardware_cursor,
             node.has_fullscreen(),
+            fill_black_in_grace_period,
             node.global.persistent.transform.get(),
         )
     }
@@ -432,6 +436,7 @@ impl dyn GfxFramebuffer {
         render_cursor: bool,
         render_hardware_cursor: bool,
         black_background: bool,
+        fill_black_in_grace_period: bool,
         transform: Transform,
     ) -> Result<Option<SyncFile>, GfxError> {
         let pass = self.create_render_pass(
@@ -442,6 +447,7 @@ impl dyn GfxFramebuffer {
             render_cursor,
             render_hardware_cursor,
             black_background,
+            fill_black_in_grace_period,
             transform,
             None,
         );
@@ -722,9 +728,16 @@ pub fn create_render_pass(
     render_cursor: bool,
     render_hardware_cursor: bool,
     black_background: bool,
+    fill_black_in_grace_period: bool,
     transform: Transform,
     visualizer: Option<&DamageVisualizer>,
 ) -> GfxRenderPass {
+    if fill_black_in_grace_period && state.idle.in_grace_period.get() {
+        return GfxRenderPass {
+            ops: vec![],
+            clear: Some(Color::SOLID_BLACK),
+        };
+    }
     let mut ops = vec![];
     let mut renderer = Renderer {
         base: renderer_base(physical_size, &mut ops, scale, transform),