solve for lint

# Conflicts:
#	selfdrive/ui/sunnypilot/layouts/settings/display.py

common/params_keys.h

@@ -179,6 +179,8 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"QuietMode", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"RainbowMode", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"RocketFuel", {PERSISTENT | BACKUP, BOOL, "0"}},
+    {"ScreenSaverEnabled", {PERSISTENT | BACKUP, BOOL, "0"}},
+    {"ScreenSaverTimeout", {PERSISTENT | BACKUP, INT, "300"}},
     {"ShowAdvancedControls", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"ShowTurnSignals", {PERSISTENT | BACKUP, BOOL, "0"}},
     {"StandstillTimer", {PERSISTENT | BACKUP, BOOL, "0"}},

selfdrive/ui/sunnypilot/layouts/settings/display.py

@@ -11,7 +11,7 @@ from openpilot.system.ui.sunnypilot.widgets.option_control import OptionControlS
 from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.lib.multilang import tr
 from openpilot.system.ui.widgets.scroller_tici import Scroller
-from openpilot.system.ui.sunnypilot.widgets.list_view import option_item_sp, ToggleActionSP
+from openpilot.system.ui.sunnypilot.widgets.list_view import toggle_item_sp, option_item_sp, ToggleActionSP
 from openpilot.sunnypilot.system.params_migration import ONROAD_BRIGHTNESS_TIMER_VALUES
 
 
@@ -64,10 +64,27 @@ class DisplayLayout(Widget):
                                     f"{value} s" if value < 60 else f"{int(value/60)} m"),
       inline=True
     )
+    self._screensaver_toggle = toggle_item_sp(
+      param="ScreenSaverEnabled",
+      title=lambda: tr("Enable sunnypilot Screen Saver"),
+      description=lambda: tr("Enable screen saver when the device is offroad & idle. " +
+                             "The screen saver will kick off after the interactivity timeout expires, and will stay on for the duration configured below."),
+    )
+    self._screensaver_timeout = option_item_sp(
+      param="ScreenSaverTimeout",
+      title=lambda: tr("Screen Saver Timeout"),
+      description=lambda: tr("Configure how long the screen saver should stay on after the interactivity timeout expires."),
+      min_value=60,
+      max_value=600,
+      value_change_step=60,
+      label_callback=lambda value: f"{int(value/60)} m"
+    )
     items = [
       self._onroad_brightness,
       self._onroad_brightness_timer,
       self._interactivity_timeout,
+      self._screensaver_toggle,
+      self._screensaver_timeout,
     ]
     return items
 
@@ -100,6 +117,8 @@ class DisplayLayout(Widget):
     brightness_val = self._params.get("OnroadScreenOffBrightness", return_default=True)
     self._onroad_brightness_timer.action_item.set_enabled(brightness_val not in (OnroadBrightness.AUTO, OnroadBrightness.AUTO_DARK))
 
+    self._screensaver_timeout.set_visible(self._screensaver_toggle.action_item.get_state())
+
   def _render(self, rect):
     self._scroller.render(rect)
 

selfdrive/ui/sunnypilot/ui_state.py

@@ -11,6 +11,7 @@ from openpilot.common.params import Params
 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.display import OnroadBrightness
 from openpilot.sunnypilot.sunnylink.sunnylink_state import SunnylinkState
 from openpilot.system.ui.lib.application import gui_app
+from openpilot.system.ui.sunnypilot.widgets.screen_saver import ScreenSaverSP
 
 OpenpilotState = log.SelfdriveState.OpenpilotState
 MADSState = custom.ModularAssistiveDrivingSystem.ModularAssistiveDrivingSystemState
@@ -34,6 +35,8 @@ class UIStateSP:
     ]
 
     self.sunnylink_state = SunnylinkState()
+    self.screensaver = ScreenSaverSP()
+
     self.update_params()
 
     self.onroad_brightness_timer: int = 0
@@ -146,14 +149,27 @@ class UIStateSP:
     self.true_v_ego_ui = self.params.get_bool("TrueVEgoUI")
     self.turn_signals = self.params.get_bool("ShowTurnSignals")
     self.boot_offroad_mode = self.params.get("DeviceBootMode", return_default=True)
+    self.screensaver_enabled = self.params.get_bool("ScreenSaverEnabled")
 
 
 class DeviceSP:
   @staticmethod
-  def _set_awake(on: bool, _ui_state):
+  def _set_awake(_device, on: bool, _ui_state):
     if _ui_state.boot_offroad_mode == 1 and not on:
       _ui_state.params.put_bool("OffroadMode", True)
 
+    if not on and _ui_state.screensaver_enabled:
+      if _ui_state.screensaver.was_dismissed:
+        _ui_state.screensaver.deinit()
+        gui_app.pop_widget()
+        return True
+      else:
+        _ui_state.screensaver.initialize(dismiss_callback=lambda: _device._set_awake(False))
+        gui_app.push_widget(_ui_state.screensaver)
+        return False
+
+    return True
+
   @staticmethod
   def set_onroad_brightness(_ui_state, awake: bool, cur_brightness: float) -> float:
     if not awake or not _ui_state.started:

selfdrive/ui/ui_state.py

@@ -299,11 +299,11 @@ class Device(DeviceSP):
 
   def _set_awake(self, on: bool):
     if on != self._awake:
-      DeviceSP._set_awake(on, ui_state)
+      if DeviceSP._set_awake(self, on, ui_state):
-      self._awake = on
+        self._awake = on
-      cloudlog.debug(f"setting display power {int(on)}")
+        cloudlog.debug(f"setting display power {int(on)}")
-      HARDWARE.set_display_power(on)
+        HARDWARE.set_display_power(on)
-      gui_app.set_should_render(on)
+        gui_app.set_should_render(on)
 
 
 # Global instance

sunnypilot/sunnylink/params_metadata.json

@@ -1126,6 +1126,14 @@
     "title": "Route Count",
     "description": ""
   },
+  "ScreenSaverEnabled": {
+    "title": "Enable Screen Saver",
+    "description": ""
+  },
+  "ScreenSaverTimeout": {
+    "title": "Screen Saver Timeout",
+    "description": ""
+  },
   "SecOCKey": {
     "title": "Sec Oc Key",
     "description": ""

system/ui/sunnypilot/widgets/screen_saver.py

@@ -0,0 +1,108 @@
+import os
+import time
+from collections.abc import Callable
+
+import pyray as rl
+
+from openpilot.common.params import Params
+from openpilot.system.hardware import HARDWARE
+from openpilot.system.ui.lib.application import gui_app, FontWeight
+from openpilot.system.ui.lib.text_measure import measure_text_cached
+from openpilot.system.ui.widgets import Widget
+
+class ScreenSaverSP(Widget):
+  def __init__(self):
+    super().__init__()
+    self.set_rect(rl.Rectangle(0, 0, gui_app.width, gui_app.height))
+    self.screensaver_timeout = Params().get("ScreenSaverTimeout", return_default=True)
+    self._is_mici = HARDWARE.get_device_type() == 'mici' or (HARDWARE.get_device_type() == "pc" and os.getenv("BIG") != "1")
+
+    self.x = 0.0
+    self.y = 100.0
+    self.vx = 120.0 if self._is_mici else 300.0
+    self.vy = 70.0 if self._is_mici else 200.0
+    self._hue = 150
+    self.color = rl.color_from_hsv(self._hue, 1, 1)
+
+    self.text = "sunnypilot"
+    self.font_size = 50 if self._is_mici else 200
+    self._start_time = None
+    self._dismiss = False
+    self.dismiss_callback = None
+
+  @property
+  def was_dismissed(self) -> bool:
+    return self._dismiss
+
+  def initialize(self, dismiss_callback: Callable):
+    if self._start_time is None:
+      self._start_time = time.monotonic()
+    self.dismiss_callback = dismiss_callback
+    self._dismiss = False
+
+  def deinit(self):
+    self._dismiss = False
+    self._start_time = None
+
+  def _handle_mouse_press(self, mouse_pos):
+    self._reset()
+    return super()._handle_mouse_press(mouse_pos)
+
+  def _reset(self):
+    self._dismiss = True
+    self._start_time = None
+
+  def _update_state(self):
+    super()._update_state()
+
+    self.font = gui_app.font(FontWeight.AUDIOWIDE)
+    text_size = measure_text_cached(self.font, self.text, self.font_size, 0)
+    self.logo_width = text_size.x
+    self.logo_height = text_size.y
+
+    if self._start_time and time.monotonic() - self._start_time > self.screensaver_timeout:
+      self._reset()
+
+    dt = rl.get_frame_time()
+
+    self.x += self.vx * dt
+    self.y += self.vy * dt
+
+    hit_x = hit_y = False
+    if self.x + self.logo_width > self.rect.width:
+      self.vx *= -1
+      self.x = self.rect.width - self.logo_width
+      hit_x = True
+    elif self.x < 0:
+      self.vx *= -1
+      self.x = 0
+      hit_x = True
+
+    if self.y + self.logo_height > self.rect.height:
+      self.vy *= -1
+      self.y = self.rect.height - self.logo_height
+      hit_y = True
+    elif self.y < 0:
+      self.vy *= -1
+      self.y = 0
+      hit_y = True
+
+    def hue_dist(a, b):
+      d = abs(a - b)
+      return min(d, 360 - d)
+
+    if hit_x or hit_y:
+      while hue_dist((new_hue := rl.get_random_value(0, 360)), self._hue) < 90:
+        pass
+      self._hue = new_hue
+      self.color = rl.color_from_hsv(self._hue, 1, 1)
+
+  def _render(self, rect: rl.Rectangle):
+    if self._dismiss:
+      self.dismiss_callback()
+      return 0
+
+    self.set_rect(rect)
+    rl.clear_background(rl.BLACK)
+    rl.draw_text_ex(self.font, self.text, rl.Vector2(int(self.x), int(self.y)), self.font_size, 0, self.color)
+    return -1