feat(idle): add per-behavior locked screen timeout

Idle behaviors get an optional locked_timeout (seconds). While the session
is locked a behavior with locked_timeout > 0 arms at that value instead of
its normal timeout, and reverts on unlock. Set timeout = 0 with
locked_timeout > 0 to run a behavior only while locked.

The main use is screen_off: turn the display off quickly on the lock screen
(and again after each wake, since the behavior re-arms) without making the
display sleep aggressively during normal use.

Re-arming a behavior that had already fired now runs its resume action
first, so unlocking while the screen is off turns it back on instead of
leaving it black.

The Settings field is shown for screen_off only.

Author: Lukas Essmann

assets/translations/en.json

@@ -1060,6 +1060,7 @@
           "suspend": "Suspend"
         },
         "kind-section-label": "Action",
+        "locked-timeout-label": "Timeout while locked (seconds, 0 = off)",
         "name-label": "Name",
         "name-placeholder": "idle-behavior",
         "resume-command-label": "Resume command",

src/app/application_ui.cpp

@@ -317,11 +317,13 @@ void Application::initLockScreenAndSession() {
       [this]() {
         m_idleGraceOverlay.hide();
         m_lockscreenWidgetsController.onLockStateChanged();
+        m_idleManager.setSessionLocked(true);
         m_hookManager.fire(HookKind::SessionLocked);
       },
       [this]() {
         m_idleGraceOverlay.hide();
         m_lockscreenWidgetsController.onLockStateChanged();
+        m_idleManager.setSessionLocked(false);
         m_hookManager.fire(HookKind::SessionUnlocked);
         requestAllSurfacesRedraw();
         if (m_logindService != nullptr) {

src/config/config_overrides.cpp

@@ -519,6 +519,9 @@ namespace {
               toml::table row;
               row.insert_or_assign("enabled", item.enabled);
               row.insert_or_assign("timeout", item.timeoutSeconds);
+              if (item.lockedTimeoutSeconds > 0.0) {
+                row.insert_or_assign("locked_timeout", item.lockedTimeoutSeconds);
+              }
               if (!item.action.empty()) {
                 row.insert_or_assign("action", item.action);
               }

src/config/config_types.h

@@ -251,6 +251,8 @@ struct IdleBehaviorConfig {
   std::string resumeCommand;
   /// When `action` is `suspend`, lock the session before running suspend so lock surfaces are ready (recommended).
   bool lockBeforeSuspend = true;
+  /// Shorter timeout (seconds) applied only while the session is locked; 0 = always use timeoutSeconds.
+  double lockedTimeoutSeconds = 0.0;
 
   bool operator==(const IdleBehaviorConfig&) const = default;
 };

src/config/schema/config_schema.cpp

@@ -841,6 +841,7 @@ namespace noctalia::config::schema {
       static const Schema<IdleBehaviorConfig> s = {
           field(&IdleBehaviorConfig::enabled, "enabled"),
           field(&IdleBehaviorConfig::timeoutSeconds, "timeout"),
+          field(&IdleBehaviorConfig::lockedTimeoutSeconds, "locked_timeout"),
           // action is trimmed on read.
           custom<IdleBehaviorConfig>(
               "action",

src/idle/idle_manager.cpp

@@ -83,6 +83,21 @@ void IdleManager::setScreenSaverInhibitLocks(std::int64_t locks) {
   }
 }
 
+void IdleManager::setSessionLocked(bool locked) {
+  if (m_sessionLocked == locked) {
+    return;
+  }
+  m_sessionLocked = locked;
+  recreateBehaviorNotifications();
+}
+
+double IdleManager::effectiveTimeoutSeconds(const IdleBehaviorConfig& config) const {
+  if (m_sessionLocked && std::isfinite(config.lockedTimeoutSeconds) && config.lockedTimeoutSeconds > 0.0) {
+    return config.lockedTimeoutSeconds;
+  }
+  return config.timeoutSeconds;
+}
+
 void IdleManager::reload(const IdleConfig& config) {
   clearBehaviors();
   m_idleConfig = config;
@@ -157,19 +172,24 @@ void IdleManager::recreateBehaviorNotification(BehaviorState& behavior) {
     return;
   }
 
+  // Re-arming an idled behavior (e.g. on unlock) has no natural resume event, so run it here —
+  // otherwise screen_off's display-off is never undone and the screen stays black.
+  if (behavior.phase == BehaviorPhase::Idled) {
+    runResumeBehavior(behavior);
+  }
+
   if (behavior.notification != nullptr) {
     ext_idle_notification_v1_destroy(behavior.notification);
     behavior.notification = nullptr;
   }
   behavior.phase = BehaviorPhase::Waiting;
 
-  if (!behavior.config.enabled
-      || !std::isfinite(behavior.config.timeoutSeconds)
-      || behavior.config.timeoutSeconds <= 0.0) {
+  const double timeout = effectiveTimeoutSeconds(behavior.config);
+  if (!behavior.config.enabled || !std::isfinite(timeout) || timeout <= 0.0) {
     return;
   }
 
-  const auto timeoutMs = timeoutSecondsToMilliseconds(behavior.config.timeoutSeconds);
+  const auto timeoutMs = timeoutSecondsToMilliseconds(timeout);
   behavior.notification = m_wayland->createIdleNotification(timeoutMs);
   if (behavior.notification == nullptr) {
     kLog.warn("failed to re-register idle behavior '{}'", behavior.config.name);
@@ -187,7 +207,7 @@ void IdleManager::recreateBehaviorNotifications() {
   for (auto& behavior : m_behaviors) {
     recreateBehaviorNotification(*behavior);
   }
-  kLog.info("idle behavior notifications reset after screensaver inhibit released");
+  kLog.debug("idle behavior notifications re-armed");
 }
 
 void IdleManager::createBehavior(const IdleBehaviorConfig& config) {
@@ -198,7 +218,11 @@ void IdleManager::createBehavior(const IdleBehaviorConfig& config) {
     kLog.warn("idle behavior '{}' ignored: timeout must be >= 0 seconds", config.name);
     return;
   }
-  if (config.timeoutSeconds == 0.0) {
+  if (!std::isfinite(config.lockedTimeoutSeconds) || config.lockedTimeoutSeconds < 0.0) {
+    kLog.warn("idle behavior '{}' ignored: locked timeout must be >= 0 seconds", config.name);
+    return;
+  }
+  if (config.timeoutSeconds == 0.0 && config.lockedTimeoutSeconds == 0.0) {
     kLog.debug("idle behavior '{}' disabled by zero timeout", config.name);
     return;
   }
@@ -211,15 +235,11 @@ void IdleManager::createBehavior(const IdleBehaviorConfig& config) {
   auto behavior = std::make_unique<BehaviorState>();
   behavior->owner = this;
   behavior->config = config;
-  const auto timeoutMs = timeoutSecondsToMilliseconds(config.timeoutSeconds);
-  behavior->notification = m_wayland->createIdleNotification(timeoutMs);
-  if (behavior->notification == nullptr) {
-    kLog.warn("failed to register idle behavior '{}'", config.name);
-    return;
-  }
-
-  ext_idle_notification_v1_add_listener(behavior->notification, &kIdleNotificationListener, behavior.get());
-  kLog.info("registered idle behavior '{}' timeout={}s", config.name, config.timeoutSeconds);
+  recreateBehaviorNotification(*behavior);
+  kLog.info(
+      "registered idle behavior '{}' timeout={}s locked_timeout={}s", config.name, config.timeoutSeconds,
+      config.lockedTimeoutSeconds
+  );
   m_behaviors.push_back(std::move(behavior));
 }
 

src/idle/idle_manager.h

@@ -41,6 +41,8 @@ class IdleManager {
   void reload(const IdleConfig& config);
   /// D-Bus screensaver inhibits (e.g. Chrome video playback). Suppresses idle actions while > 0.
   void setScreenSaverInhibitLocks(std::int64_t locks);
+  /// While locked, behaviors with a positive lockedTimeoutSeconds re-arm at that shorter timeout.
+  void setSessionLocked(bool locked);
   /// Seconds the compositor has reported session-idle (1s heartbeat notification); 0 when active.
   [[nodiscard]] std::int64_t liveIdleSeconds() const noexcept { return m_liveIdleSeconds; }
   void onSecondTick();
@@ -63,6 +65,7 @@ class IdleManager {
     BehaviorPhase phase = BehaviorPhase::Waiting;
   };
 
+  [[nodiscard]] double effectiveTimeoutSeconds(const IdleBehaviorConfig& config) const;
   void clearBehaviors();
   void syncHeartbeat();
   void destroyHeartbeat();
@@ -94,4 +97,5 @@ class IdleManager {
   std::int64_t m_liveIdleSeconds = 0;
   std::int64_t m_screenSaverInhibitLocks = 0;
   bool m_idledWhileScreenSaverInhibited = false;
+  bool m_sessionLocked = false;
 };

src/shell/settings/settings_content_idle_behavior.cpp

@@ -37,6 +37,7 @@ namespace settings {
     IdleBehaviorConfig norm = row;
     normalizeIdleBehaviorAction(norm);
     const bool showCustomCommands = (norm.action == "command");
+    const bool showLockedTimeout = (norm.action == "screen_off");
 
     auto body = ui::column({
         .align = FlexAlign::Stretch,
@@ -205,6 +206,45 @@ namespace settings {
     timeoutBlock->addChild(std::move(timeoutIn));
     body->addChild(std::move(timeoutBlock));
 
+    if (showLockedTimeout) {
+      auto lockedTimeoutBlock = ui::column(
+          {.align = FlexAlign::Stretch, .gap = Style::spaceXs * scale},
+          makeLabel(
+              i18n::tr("settings.idle.behavior.locked-timeout-label"), Style::fontSizeCaption * scale,
+              colorSpecFromRole(ColorRole::OnSurfaceVariant), FontWeight::Normal
+          )
+      );
+      Input* lockedTimeoutPtr = nullptr;
+      auto lockedTimeoutIn = ui::input({
+          .out = &lockedTimeoutPtr,
+          .value = StringUtils::formatDotDecimal(row.lockedTimeoutSeconds),
+          .placeholder = "0",
+          .fontSize = Style::fontSizeBody * scale,
+          .controlHeight = Style::controlHeight * scale,
+          .horizontalPadding = Style::spaceSm * scale,
+      });
+      const auto commitLockedTimeout = [&row, persist, lockedTimeoutPtr]() {
+        const auto parsed = parseDoubleInput(lockedTimeoutPtr->value());
+        constexpr double kMaxIdleTimeoutSeconds =
+            static_cast<double>(std::numeric_limits<std::uint32_t>::max()) / 1000.0;
+        if (!parsed.has_value() || *parsed < 0.0 || *parsed > kMaxIdleTimeoutSeconds) {
+          lockedTimeoutPtr->setInvalid(true);
+          return;
+        }
+        row.lockedTimeoutSeconds = *parsed;
+        lockedTimeoutPtr->setInvalid(false);
+        lockedTimeoutPtr->setValue(StringUtils::formatDotDecimal(row.lockedTimeoutSeconds));
+        persist();
+      };
+      lockedTimeoutIn->setOnChange([lockedTimeoutPtr](const std::string& /*t*/) {
+        lockedTimeoutPtr->setInvalid(false);
+      });
+      lockedTimeoutIn->setOnSubmit([commitLockedTimeout](const std::string& /*text*/) { commitLockedTimeout(); });
+      lockedTimeoutIn->setOnFocusLoss(commitLockedTimeout);
+      lockedTimeoutBlock->addChild(std::move(lockedTimeoutIn));
+      body->addChild(std::move(lockedTimeoutBlock));
+    }
+
     body->addChild(std::move(customCommandsGrp));
     body->addChild(std::move(resumeCommandGrp));
 

tests/config_schema_roundtrip_test.cpp

@@ -369,7 +369,7 @@ location = "https://example.invalid/bad"
     // Explicit normalized actions so normalizeIdleBehaviorAction is a no-op on read.
     c.idle.behaviors = {
         {"dim", true, 60, "lock", "", "", true},
-        {"off", false, 300, "screen_off", "", "", true},
+        {"off", false, 300, "screen_off", "", "", true, 30},
     };
     c.wallpaper.enabled = false;
     c.wallpaper.fillColor = colorSpecFromConfigString("#ff8800");