sunnylink panel

# Conflicts:
#	system/ui/sunnypilot/lib/styles.py
#	system/ui/sunnypilot/widgets/list_view.py
#	system/ui/sunnypilot/widgets/toggle.py

selfdrive/ui/layouts/main.py

@@ -13,7 +13,6 @@ from openpilot.selfdrive.ui.layouts.onboarding import OnboardingWindow
 if gui_app.sunnypilot_ui():
   from openpilot.selfdrive.ui.sunnypilot.layouts.settings.settings import SettingsLayoutSP as SettingsLayout
 
-
 class MainState(IntEnum):
   HOME = 0
   SETTINGS = 1

selfdrive/ui/mici/layouts/home.py

@@ -118,6 +118,9 @@ class MiciHomeLayout(Widget):
     self._branch_label = MiciLabel("", font_size=36, color=rl.GRAY, font_weight=FontWeight.ROMAN, elide_right=False, scroll=True)
     self._version_commit_label = MiciLabel("", font_size=36, color=rl.GRAY, font_weight=FontWeight.ROMAN)
 
+    if gui_app.sunnypilot_ui():
+      self._openpilot_label.set_text("sunnypilot")
+
   def show_event(self):
     self._version_text = self._get_version_text()
     self._update_network_status(ui_state.sm['deviceState'])

selfdrive/ui/mici/layouts/main.py

@@ -2,7 +2,7 @@ import pyray as rl
 from enum import IntEnum
 import cereal.messaging as messaging
 from openpilot.selfdrive.ui.mici.layouts.home import MiciHomeLayout
-from openpilot.selfdrive.ui.mici.layouts.settings.settings import SettingsLayout
+from openpilot.selfdrive.ui.sunnypilot.mici.layouts.settings import SettingsLayoutSP as SettingsLayout
 from openpilot.selfdrive.ui.mici.layouts.offroad_alerts import MiciOffroadAlerts
 from openpilot.selfdrive.ui.mici.onroad.augmented_road_view import AugmentedRoadView
 from openpilot.selfdrive.ui.ui_state import device, ui_state

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

@@ -1,12 +1,6 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-from openpilot.common.params import Params
 from openpilot.system.ui.widgets.scroller_tici import Scroller
 from openpilot.system.ui.widgets import Widget
+from openpilot.common.params import Params
 
 
 class CruiseLayout(Widget):

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

@@ -1,12 +1,5 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
 from openpilot.selfdrive.ui.layouts.settings.device import DeviceLayout
 
-
 class DeviceLayoutSP(DeviceLayout):
   def __init__(self):
     DeviceLayout.__init__(self)

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

@@ -1,12 +1,6 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-from openpilot.common.params import Params
 from openpilot.system.ui.widgets.scroller_tici import Scroller
 from openpilot.system.ui.widgets import Widget
+from openpilot.common.params import Params
 
 
 class DisplayLayout(Widget):

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

@@ -1,12 +1,6 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-from openpilot.common.params import Params
 from openpilot.system.ui.widgets.scroller_tici import Scroller
 from openpilot.system.ui.widgets import Widget
+from openpilot.common.params import Params
 
 
 class ModelsLayout(Widget):

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

@@ -1,12 +1,6 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-from openpilot.common.params import Params
 from openpilot.system.ui.widgets.scroller_tici import Scroller
 from openpilot.system.ui.widgets import Widget
+from openpilot.common.params import Params
 
 
 class NavigationLayout(Widget):

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

@@ -1,12 +1,6 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-from openpilot.common.params import Params
 from openpilot.system.ui.widgets.scroller_tici import Scroller
 from openpilot.system.ui.widgets import Widget
+from openpilot.common.params import Params
 
 
 class OSMLayout(Widget):

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

@@ -1,22 +1,14 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
+import pyray as rl
 from dataclasses import dataclass
 from enum import IntEnum
-
-import pyray as rl
 from openpilot.selfdrive.ui.layouts.settings import settings as OP
 from openpilot.selfdrive.ui.layouts.settings.developer import DeveloperLayout
 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.device import DeviceLayoutSP
 from openpilot.selfdrive.ui.layouts.settings.firehose import FirehoseLayout
 from openpilot.selfdrive.ui.layouts.settings.software import SoftwareLayout
 from openpilot.selfdrive.ui.layouts.settings.toggles import TogglesLayout
-from openpilot.system.ui.lib.application import gui_app, MousePos
+from openpilot.system.ui.lib.application import gui_app,MousePos
 from openpilot.system.ui.lib.multilang import tr_noop
-from openpilot.system.ui.sunnypilot.lib.styles import style
 from openpilot.system.ui.widgets.scroller_tici import Scroller
 from openpilot.system.ui.lib.text_measure import measure_text_cached
 from openpilot.system.ui.widgets.network import NetworkUI
@@ -31,13 +23,12 @@ from openpilot.selfdrive.ui.sunnypilot.layouts.settings.steering import Steering
 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.cruise import CruiseLayout
 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.visuals import VisualsLayout
 from openpilot.selfdrive.ui.sunnypilot.layouts.settings.display import DisplayLayout
-
-# from openpilot.selfdrive.ui.sunnypilot.layouts.settings.navigation import NavigationLayout
+#from openpilot.selfdrive.ui.sunnypilot.layouts.settings.navigation import NavigationLayout
 
 OP.PANEL_COLOR = rl.Color(10, 10, 10, 255)
 ICON_SIZE = 70
 
-OP.PanelType = IntEnum(  # type: ignore
+OP.PanelType = IntEnum( # type: ignore
   "PanelType",
   [es.name for es in OP.PanelType] + [
     "SUNNYLINK",
@@ -52,8 +43,7 @@ OP.PanelType = IntEnum(  # type: ignore
     "VEHICLE",
   ],
   start=0,
-)
-
+  )
 
 @dataclass
 class PanelInfo(OP.PanelInfo):
@@ -66,7 +56,7 @@ class SettingsLayoutSP(OP.SettingsLayout):
     self._nav_items: list[Widget] = []
 
     # Create sidebar scroller
-    self._sidebar_scroller = Scroller([], spacing=0, line_separator=False, pad_end=False)
+    self._sidebar_scroller = Scroller([], spacing=0, line_separator = False, pad_end=False)
 
     # Panel configuration
     wifi_manager = WifiManager()
@@ -84,7 +74,7 @@ class SettingsLayoutSP(OP.SettingsLayout):
       OP.PanelType.VISUALS: PanelInfo(tr_noop("Visuals"), VisualsLayout(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_visuals.png"),
       OP.PanelType.DISPLAY: PanelInfo(tr_noop("Display"), DisplayLayout(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_display.png"),
       OP.PanelType.OSM: PanelInfo(tr_noop("OSM"), OSMLayout(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_map.png"),
-      # OP.PanelType.NAVIGATION: PanelInfo(tr_noop("Navigation"), NavigationLayout(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_map.png"),
+      #OP.PanelType.NAVIGATION: PanelInfo(tr_noop("Navigation"), NavigationLayout(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_map.png"),
       OP.PanelType.TRIPS: PanelInfo(tr_noop("Trips"), TripsLayout(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_trips.png"),
       OP.PanelType.VEHICLE: PanelInfo(tr_noop("Vehicle"), VehicleLayout(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_vehicle.png"),
       OP.PanelType.FIREHOSE: PanelInfo(tr_noop("Firehose"), FirehoseLayout(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_firehose.png"),
@@ -108,7 +98,7 @@ class SettingsLayoutSP(OP.SettingsLayout):
         # Draw background if selected
         if is_selected:
           self.container_rect = rl.Rectangle(
-            content_x - 50, rect.y, OP.SIDEBAR_WIDTH - 50, OP.NAV_BTN_HEIGHT
+            content_x - 20, rect.y, OP.SIDEBAR_WIDTH - 70, OP.NAV_BTN_HEIGHT
           )
           rl.draw_rectangle_rounded(self.container_rect, 0.2, 5, OP.CLOSE_BTN_COLOR)
 
@@ -134,7 +124,7 @@ class SettingsLayoutSP(OP.SettingsLayout):
 
     # Close button
     close_btn_rect = rl.Rectangle(
-      rect.x + style.ITEM_PADDING * 3, rect.y + style.ITEM_PADDING * 2, style.CLOSE_BTN_SIZE, style.CLOSE_BTN_SIZE
+      rect.x + (rect.width - OP.CLOSE_BTN_SIZE) / 2, rect.y + 60, OP.CLOSE_BTN_SIZE, OP.CLOSE_BTN_SIZE
     )
 
     pressed = (rl.is_mouse_button_down(rl.MouseButton.MOUSE_BUTTON_LEFT) and
@@ -148,7 +138,7 @@ class SettingsLayoutSP(OP.SettingsLayout):
       close_btn_rect.y + (close_btn_rect.height - self._close_icon.height) / 2,
       self._close_icon.width,
       self._close_icon.height,
-    )
+      )
     rl.draw_texture_pro(
       self._close_icon,
       rl.Rectangle(0, 0, self._close_icon.width, self._close_icon.height),
@@ -173,7 +163,7 @@ class SettingsLayoutSP(OP.SettingsLayout):
     # Draw navigation section with scroller
     nav_rect = rl.Rectangle(
       rect.x,
-      self._close_btn_rect.height + style.ITEM_PADDING * 4,  # Starting Y position for nav items
+      rect.y + 300,  # Starting Y position for nav items
       rect.width,
       rect.height - 300  # Remaining height after close button
     )
@@ -182,6 +172,7 @@ class SettingsLayoutSP(OP.SettingsLayout):
       self._sidebar_scroller.render(nav_rect)
       return
 
+
   def _handle_mouse_release(self, mouse_pos: MousePos) -> bool:
     # Check close button
     if rl.check_collision_point_rec(mouse_pos, self._close_btn_rect):

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

@@ -1,12 +1,6 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-from openpilot.common.params import Params
 from openpilot.system.ui.widgets.scroller_tici import Scroller
 from openpilot.system.ui.widgets import Widget
+from openpilot.common.params import Params
 
 
 class SteeringLayout(Widget):

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

@@ -1,12 +1,16 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-from openpilot.common.params import Params
+from cereal import custom
+from openpilot.selfdrive.ui.sunnypilot.ui_state import ui_state_sp
+from openpilot.sunnypilot.sunnylink.api import UNREGISTERED_SUNNYLINK_DONGLE_ID
+from openpilot.system.ui.lib.application import gui_app
+from openpilot.system.ui.lib.multilang import tr
+from openpilot.system.ui.sunnypilot.widgets.sunnylink_pairing_dialog import SunnylinkPairingDialog
+from openpilot.system.ui.widgets.button import ButtonStyle, Button
+from openpilot.system.ui.widgets.confirm_dialog import alert_dialog, ConfirmDialog
+from openpilot.system.ui.widgets.list_view import button_item, dual_button_item
 from openpilot.system.ui.widgets.scroller_tici import Scroller
-from openpilot.system.ui.widgets import Widget
+from openpilot.system.ui.widgets import Widget, DialogResult
+from openpilot.common.params import Params
+from openpilot.system.ui.sunnypilot.widgets.list_view import toggle_item_sp
 
 
 class SunnylinkLayout(Widget):
@@ -14,15 +18,162 @@ class SunnylinkLayout(Widget):
     super().__init__()
 
     self._params = Params()
+    self._sunnylink_pairing_dialog: SunnylinkPairingDialog | None = None
+    self._restore_in_progress = False
+    self._backup_in_progress = False
+    self._sunnylink_enabled = self._params.get("SunnylinkEnabled")
+
     items = self._initialize_items()
     self._scroller = Scroller(items, line_separator=True, spacing=0)
 
   def _initialize_items(self):
-    items = [
+    self._sunnylink_toggle = toggle_item_sp(
+      title=tr("Enable sunnylink"),
+      description=tr(
+        "This is the master switch, it will allow you to cutoff any sunnylink requests should you want to do that."),
+      param="SunnylinkEnabled"
+    )
+    self._sponsor_btn = button_item(
+      title=tr("Sponsor Status"),
+      button_text=tr("SPONSOR"),
+      description=tr(
+        "Become a sponsor of sunnypilot to get early access to sunnylink features when they become available."),
+      callback=lambda: self._handle_pair_btn(False)
+    )
+    self._pair_btn = button_item(
+      title=tr("Pair GitHub Account"),
+      button_text=tr("Not Paired"),
+      description=tr(
+        "Pair your GitHub account to grant your device sponsor benefits, including API access on sunnylink."),
+      callback=lambda: self._handle_pair_btn(True)
+    )
+    self._sunnylink_uploader_toggle = toggle_item_sp(
+      title=tr("Enable sunnylink uploader (infrastructure test)"),
+      description=tr("Enable sunnylink uploader to allow sunnypilot to upload your driving data to sunnypilot servers.") +
+                  tr(" (Only for highest tiers, and does NOT bring ANY benefit to you yet. We are just testing data volume.)"),
+      param="EnableSunnylinkUploader"
+    )
+    self._sunnylink_backup_restore_buttons = dual_button_item(
+      description="",
+      left_text=tr("Backup Settings"),
+      right_text=tr("Restore Settings"),
+      left_callback=self._handle_backup_btn,
+      right_callback=self._handle_restore_btn
+    )
+    self._backup_btn: Button = self._sunnylink_backup_restore_buttons.action_item.left_button # store for easy individual access
+    self._restore_btn: Button = self._sunnylink_backup_restore_buttons.action_item.right_button
+    self._backup_btn.set_button_style(ButtonStyle.NORMAL)
+    self._restore_btn.set_button_style(ButtonStyle.PRIMARY)
 
+    items = [
+      self._sunnylink_toggle,
+      self._sponsor_btn,
+      self._pair_btn,
+      self._sunnylink_uploader_toggle,
+      self._sunnylink_backup_restore_buttons
     ]
     return items
 
+  def _handle_pair_btn(self, sponsor_pairing: bool = False):
+    sunnylink_dongle_id = self._params.get("SunnylinkDongleId") or UNREGISTERED_SUNNYLINK_DONGLE_ID
+    if sunnylink_dongle_id == UNREGISTERED_SUNNYLINK_DONGLE_ID:
+      gui_app.set_modal_overlay(alert_dialog(message=tr("sunnylink Dongle ID not found. ") +
+                                                     tr("This may be due to weak internet connection or sunnylink registration issue. ") +
+                                                     tr("Please reboot and try again.")))
+    elif not self._sunnylink_pairing_dialog:
+      self._sunnylink_pairing_dialog = SunnylinkPairingDialog(sponsor_pairing)
+      gui_app.set_modal_overlay(self._sunnylink_pairing_dialog, callback=lambda result: setattr(self, '_sunnylink_pairing_dialog', None))
+
+  def _handle_backup_btn(self):
+    gui_app.set_modal_overlay(alert_dialog(message=tr("Backup functionality is currently not available.") +
+                                                   tr(" It will be back once all settings are implemented on raylib.")))
+    # backup_dialog = ConfirmDialog(text=tr("Are you sure you want to backup your current sunnypilot settings?"), confirm_text="Backup")
+    # gui_app.set_modal_overlay(backup_dialog, callback=self._backup_handler)
+
+  def _handle_restore_btn(self):
+    self._restore_btn.set_enabled(False)
+    restore_dialog = ConfirmDialog(text=tr("Are you sure you want to restore the last backed up sunnypilot settings?"), confirm_text="Restore")
+    gui_app.set_modal_overlay(restore_dialog, callback=self._restore_handler)
+
+  def _backup_handler(self, dialog_result: int):
+    if dialog_result == DialogResult.CONFIRM:
+      self._backup_in_progress = True
+      self._backup_btn.set_enabled(False)
+      self._params.put_bool("BackupManager_CreateBackup", True)
+
+  def _restore_handler(self, dialog_result: int):
+    if dialog_result == DialogResult.CONFIRM:
+      self._restore_in_progress = True
+      self._restore_btn.set_enabled(False)
+      self._params.put("BackupManager_RestoreVersion", "latest")
+
+  def handle_backup_restore_progress(self):
+    sunnylink_backup_manager = ui_state_sp.sm["backupManagerSP"]
+
+    backup_status = sunnylink_backup_manager.backupStatus
+    restore_status = sunnylink_backup_manager.restoreStatus
+    backup_progress = sunnylink_backup_manager.backupProgress
+    restore_progress = sunnylink_backup_manager.restoreProgress
+
+    if self._backup_in_progress:
+      if backup_status == custom.BackupManagerSP.Status.inProgress:
+        text = tr(f"Backing up {backup_progress}%")
+        self._backup_btn.set_text(text)
+
+      elif backup_status == custom.BackupManagerSP.Status.failed:
+        self._backup_in_progress = False
+        self._backup_btn.set_enabled(not ui_state_sp.is_onroad())
+        self._backup_btn.set_text(tr("Backup Failed"))
+
+      elif backup_status == custom.BackupManagerSP.Status.completed:
+        self._backup_in_progress = False
+        dialog = alert_dialog(tr("Settings backup completed."))
+        gui_app.set_modal_overlay(dialog)
+        self._backup_btn.set_enabled(not ui_state_sp.is_onroad())
+
+    elif self._restore_in_progress:
+      if restore_status == custom.BackupManagerSP.Status.inProgress:
+        self._restore_btn.set_enabled(False)
+        text = tr(f"Restoring {restore_progress}%")
+        self._restore_btn.set_text(text)
+
+      elif restore_status == custom.BackupManagerSP.Status.failed:
+        self._restore_in_progress = False
+        self._restore_btn.set_enabled(not ui_state_sp.is_onroad())
+        self._restore_btn.set_text(tr("Restore Failed"))
+        dialog = alert_dialog(tr("Unable to restore the settings, try again later."))
+        gui_app.set_modal_overlay(dialog)
+
+      elif restore_status == custom.BackupManagerSP.Status.completed:
+        self._restore_in_progress = False
+        dialog = alert_dialog(tr("Settings restored. Confirm to restart the interface."))
+        gui_app.set_modal_overlay(dialog, callback=lambda: {
+          gui_app.request_close()
+        })
+
+    else:
+      can_enable =  self._sunnylink_enabled and not ui_state_sp.is_onroad()
+      self._backup_btn.set_enabled(can_enable)
+      self._backup_btn.set_text(tr("Backup Settings"))
+      self._restore_btn.set_enabled(can_enable)
+      self._restore_btn.set_text(tr("Restore Settings"))
+
+  def _update_state(self):
+    super()._update_state()
+    self._sunnylink_enabled = self._params.get("SunnylinkEnabled")
+    self._sunnylink_toggle.action_item.set_enabled(not ui_state_sp.is_onroad())
+    self._sunnylink_toggle.action_item.set_state(self._sunnylink_enabled)
+    self._sunnylink_uploader_toggle.action_item.set_enabled(self._sunnylink_enabled)
+    self.handle_backup_restore_progress()
+
+    sponsor_btn_text = tr("THANKS ♥") if ui_state_sp.sunnylink_state.is_sponsor() else tr("SPONSOR")
+    self._sponsor_btn.action_item.set_text(sponsor_btn_text)
+    self._sponsor_btn.action_item.set_enabled(self._sunnylink_enabled)
+
+    pair_btn_text = tr("Paired") if ui_state_sp.sunnylink_state.is_paired() else tr("Not Paired")
+    self._pair_btn.action_item.set_text(pair_btn_text)
+    self._pair_btn.action_item.set_enabled(self._sunnylink_enabled)
+
   def _render(self, rect):
     self._scroller.render(rect)
 

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

@@ -1,12 +1,6 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-from openpilot.common.params import Params
 from openpilot.system.ui.widgets.scroller_tici import Scroller
 from openpilot.system.ui.widgets import Widget
+from openpilot.common.params import Params
 
 
 class TripsLayout(Widget):

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

@@ -1,12 +1,6 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-from openpilot.common.params import Params
 from openpilot.system.ui.widgets.scroller_tici import Scroller
 from openpilot.system.ui.widgets import Widget
+from openpilot.common.params import Params
 
 
 class VehicleLayout(Widget):

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

@@ -1,12 +1,6 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-from openpilot.common.params import Params
 from openpilot.system.ui.widgets.scroller_tici import Scroller
 from openpilot.system.ui.widgets import Widget
+from openpilot.common.params import Params
 
 
 class VisualsLayout(Widget):

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

@@ -0,0 +1,40 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+from enum import IntEnum
+
+import pyray as rl
+from openpilot.selfdrive.ui.mici.layouts.settings import settings as OP
+from openpilot.selfdrive.ui.mici.widgets.button import BigButton
+from openpilot.selfdrive.ui.sunnypilot.mici.layouts.sunnylink import SunnylinkLayoutMici
+
+OP.PANEL_COLOR = rl.Color(10, 10, 10, 255)
+ICON_SIZE = 70
+
+OP.PanelType = IntEnum(  # type: ignore
+  "PanelType",
+  [es.name for es in OP.PanelType] + [
+    "SUNNYLINK",
+  ],
+  start=0,
+)
+
+class SettingsLayoutSP(OP.SettingsLayout):
+  def __init__(self):
+    OP.SettingsLayout.__init__(self)
+
+    sunnylink_btn = BigButton("sunnylink", "", "icons_mici/settings/developer/ssh.png")
+    sunnylink_btn.set_click_callback(lambda: self._set_current_panel(OP.PanelType.SUNNYLINK))
+    self._panels.update({
+      OP.PanelType.SUNNYLINK: OP.PanelInfo("sunnylink", SunnylinkLayoutMici(back_callback=lambda: self._set_current_panel(None))),
+    })
+
+    items = self._scroller._items.copy()
+
+    items.insert(1, sunnylink_btn)
+    self._scroller._items.clear()
+    for item in items:
+      self._scroller.add_widget(item)

selfdrive/ui/sunnypilot/mici/layouts/sunnylink.py

@@ -0,0 +1,170 @@
+import pyray as rl
+from collections.abc import Callable
+from cereal import log, custom
+from openpilot.common.params_pyx import Params
+from openpilot.selfdrive.ui.mici.widgets.dialog import BigDialog, BigConfirmationDialogV2
+from openpilot.selfdrive.ui.sunnypilot.mici.widgets.sunnylink_pairing_dialog import SunnylinkPairingDialog
+from openpilot.sunnypilot.sunnylink.api import UNREGISTERED_SUNNYLINK_DONGLE_ID
+from openpilot.system.ui.lib.multilang import tr
+
+from openpilot.system.ui.widgets.scroller import Scroller
+from openpilot.selfdrive.ui.mici.widgets.button import BigParamControl, BigButton, BigToggle
+from openpilot.system.ui.lib.application import gui_app, MousePos
+from openpilot.system.ui.widgets import NavWidget
+from openpilot.selfdrive.ui.layouts.settings.common import restart_needed_callback
+from openpilot.selfdrive.ui.sunnypilot.ui_state import ui_state_sp
+
+
+
+class SunnylinkLayoutMici(NavWidget):
+  def __init__(self, back_callback: Callable):
+    super().__init__()
+    self.set_back_callback(back_callback)
+    self._restore_in_progress = False
+    self._backup_in_progress = False
+    self._sunnylink_enabled = ui_state_sp.params.get("SunnylinkEnabled")
+
+    self._sunnylink_toggle = BigToggle(text="enable sunnylink",
+                                       initial_state=self._sunnylink_enabled,
+                                       toggle_callback=self._sunnylink_toggle_callback)
+    self._sunnylink_pair_button = SunnylinkPairBigButton()
+    self._sunnylink_sponsor_button = SunnylinkPairBigButton(sponsor_pairing=True)
+    self._backup_btn = BigButton("backup settings", "", "")
+    self._backup_btn.set_click_callback(lambda: self._handle_backup_restore_btn(restore=False))
+    self._restore_btn = BigButton("restore settings", "", "")
+    self._restore_btn.set_click_callback(lambda: self._handle_backup_restore_btn(restore=True))
+
+    self._scroller = Scroller([
+      self._sunnylink_toggle,
+      self._sunnylink_pair_button,
+      self._sunnylink_sponsor_button,
+      self._backup_btn,
+      self._restore_btn,
+    ], snap_items=False)
+
+  def _update_state(self):
+    super()._update_state()
+    self._sunnylink_enabled = ui_state_sp.sunnylink_enabled
+    self._sunnylink_toggle.set_text("disable sunnylink" if self._sunnylink_enabled else "enable sunnylink")
+    self._sunnylink_pair_button.set_visible(self._sunnylink_enabled)
+    self._sunnylink_sponsor_button.set_visible(self._sunnylink_enabled)
+    self._backup_btn.set_visible(self._sunnylink_enabled)
+    self._restore_btn.set_visible(self._sunnylink_enabled)
+    self.handle_backup_restore_progress()
+
+  def show_event(self):
+    super().show_event()
+    self._scroller.show_event()
+    ui_state_sp.update_params()
+
+  def _render(self, rect: rl.Rectangle):
+    self._scroller.render(rect)
+
+  def _sunnylink_toggle_callback(self, state: bool):
+    ui_state_sp.params.put_bool("SunnylinkEnabled", state)
+    ui_state_sp.update_params()
+
+  def _handle_backup_restore_btn(self, restore:bool = False):
+    lbl = tr("slide to restore") if restore else tr("slide to backup")
+    icon = "icons_mici/settings/network/new/trash.png"
+    dlg = BigConfirmationDialogV2(lbl, icon, confirm_callback=None)
+    gui_app.set_modal_overlay(dlg, callback=self._restore_handler if restore else self._backup_handler)
+
+  def _backup_handler(self, dialog_result: int):
+    self._backup_in_progress = True
+    self._backup_btn.set_enabled(False)
+    ui_state_sp.params.put_bool("BackupManager_CreateBackup", True)
+
+  def _restore_handler(self, dialog_result: int):
+    self._restore_in_progress = True
+    self._restore_btn.set_enabled(False)
+    ui_state_sp.params.put("BackupManager_RestoreVersion", "latest")
+
+  def handle_backup_restore_progress(self):
+    sunnylink_backup_manager = ui_state_sp.sm["backupManagerSP"]
+
+    backup_status = sunnylink_backup_manager.backupStatus
+    restore_status = sunnylink_backup_manager.restoreStatus
+    backup_progress = sunnylink_backup_manager.backupProgress
+    restore_progress = sunnylink_backup_manager.restoreProgress
+
+    if self._backup_in_progress:
+      if backup_status == custom.BackupManagerSP.Status.inProgress:
+        text = tr(f"{backup_progress}%")
+        self._backup_btn.set_value(text)
+
+      elif backup_status == custom.BackupManagerSP.Status.failed:
+        self._backup_in_progress = False
+        self._backup_btn.set_enabled(not ui_state_sp.is_onroad())
+        self._backup_btn.set_value(tr("Failed"))
+
+      elif backup_status == custom.BackupManagerSP.Status.completed:
+        self._backup_in_progress = False
+        dialog = BigDialog(title=tr("Settings backed up"), description="")
+        gui_app.set_modal_overlay(dialog)
+        self._backup_btn.set_enabled(not ui_state_sp.is_onroad())
+
+    elif self._restore_in_progress:
+      if restore_status == custom.BackupManagerSP.Status.inProgress:
+        self._restore_btn.set_enabled(False)
+        text = tr(f"{restore_progress}%")
+        self._restore_btn.set_value(text)
+
+      elif restore_status == custom.BackupManagerSP.Status.failed:
+        self._restore_in_progress = False
+        self._restore_btn.set_enabled(not ui_state_sp.is_onroad())
+        self._restore_btn.set_value(tr("Failed"))
+        dialog = BigDialog(title=tr("Unable to restore"), description="Try again later.")
+        gui_app.set_modal_overlay(dialog)
+
+      elif restore_status == custom.BackupManagerSP.Status.completed:
+        self._restore_in_progress = False
+        dialog = BigConfirmationDialogV2("slide to restart", "", confirm_callback=None)
+        gui_app.set_modal_overlay(dialog, callback=lambda: {
+          gui_app.request_close()
+        })
+
+    else:
+      can_enable = self._sunnylink_enabled and not ui_state_sp.is_onroad()
+      self._backup_btn.set_enabled(can_enable)
+      self._backup_btn.set_text(tr("backup settings"))
+      self._restore_btn.set_enabled(can_enable)
+      self._restore_btn.set_text(tr("restore settings"))
+
+
+
+class SunnylinkPairBigButton(BigButton):
+  def __init__(self, sponsor_pairing: bool = False):
+    self.sponsor_pairing = sponsor_pairing
+    super().__init__("", "", "")
+
+  def _update_state(self):
+    self.set_value("")
+    self.set_enabled(True)
+
+    if self.sponsor_pairing:
+      if ui_state_sp.sunnylink_state.is_sponsor():
+        self.set_text("thanks")
+        self.set_value("for sponsoring")
+        self.set_enabled(False)
+      else:
+        self.set_text("sponsor")
+    else:
+      if ui_state_sp.sunnylink_state.is_paired():
+        self.set_text(tr("paired"))
+        self.set_enabled(False)
+      else:
+        self.set_text(tr("pair"))
+
+  def _handle_mouse_release(self, mouse_pos: MousePos):
+    super()._handle_mouse_release(mouse_pos)
+
+    dlg: BigDialog | SunnylinkPairingDialog | None = None
+    if UNREGISTERED_SUNNYLINK_DONGLE_ID == (ui_state_sp.params.get("SunnylinkDongleId") or UNREGISTERED_SUNNYLINK_DONGLE_ID):
+      dlg = BigDialog(tr("sunnylink Dongle ID not found. Please reboot & try again."), "")
+    elif self.sponsor_pairing and not ui_state_sp.sunnylink_state.is_sponsor():
+      dlg = SunnylinkPairingDialog(sponsor_pairing=True)
+    elif not self.sponsor_pairing and not ui_state_sp.sunnylink_state.is_paired():
+      dlg = SunnylinkPairingDialog(sponsor_pairing=False)
+    if dlg:
+      gui_app.set_modal_overlay(dlg)

selfdrive/ui/sunnypilot/mici/widgets/sunnylink_pairing_dialog.py

@@ -0,0 +1,53 @@
+import base64
+
+import pyray as rl
+from openpilot.common.swaglog import cloudlog
+from openpilot.selfdrive.ui.sunnypilot.ui_state import ui_state_sp
+from openpilot.selfdrive.ui.mici.widgets.pairing_dialog import PairingDialog
+from openpilot.sunnypilot.sunnylink.api import SunnylinkApi, UNREGISTERED_SUNNYLINK_DONGLE_ID, API_HOST
+from openpilot.system.ui.lib.application import FontWeight, gui_app
+from openpilot.system.ui.lib.multilang import tr
+from openpilot.system.ui.widgets.label import MiciLabel
+
+
+class SunnylinkPairingDialog(PairingDialog):
+  """Dialog for device pairing with QR code."""
+
+  QR_REFRESH_INTERVAL = 300  # 5 minutes in seconds
+
+  def __init__(self, sponsor_pairing: bool = False):
+    PairingDialog.__init__(self)
+    self._sponsor_pairing = sponsor_pairing
+    label_text = tr("become a sunnypilot sponsor") if sponsor_pairing else tr("pair with sunnylink")
+    self._pair_label = MiciLabel(label_text, 48, font_weight=FontWeight.BOLD,
+                                 color=rl.Color(255, 255, 255, int(255 * 0.9)), line_height=40, wrap_text=True)
+
+  def _get_pairing_url(self) -> str:
+    qr_string = "https://github.com/sponsors/sunnyhaibin"
+
+    if self._sponsor_pairing:
+      try:
+        sl_dongle_id = ui_state_sp.params.get("SunnylinkDongleId") or UNREGISTERED_SUNNYLINK_DONGLE_ID
+        token = SunnylinkApi(sl_dongle_id).get_token()
+        inner_string = f"1|{sl_dongle_id}|{token}"
+        payload_bytes = base64.b64encode(inner_string.encode('utf-8')).decode('utf-8')
+        qr_string = f"{API_HOST}/sso?state={payload_bytes}"
+      except Exception:
+        cloudlog.exception("Failed to get pairing token")
+
+    return qr_string
+
+  def _update_state(self):
+    if ui_state_sp.sunnylink_state.is_paired():
+      self._playing_dismiss_animation = True
+
+if __name__ == "__main__":
+  gui_app.init_window("pairing device")
+  pairing = SunnylinkPairingDialog(sponsor_pairing=True)
+  try:
+    for _ in gui_app.render():
+      result = pairing.render(rl.Rectangle(0, 0, gui_app.width, gui_app.height))
+      if result != -1:
+        break
+  finally:
+    del pairing

selfdrive/ui/sunnypilot/ui_state.py

@@ -0,0 +1,44 @@
+from collections.abc import Callable
+
+from openpilot.selfdrive.ui.ui_state import UIState
+from cereal import messaging
+from openpilot.common.params import Params
+from openpilot.sunnypilot.sunnylink.sunnylink_state import SunnylinkState
+
+
+class UIStateSP(UIState):
+  _instance: 'UIStateSP | None' = None
+
+  def _initialize(self):
+    UIState._initialize(self)
+    self.params = Params()
+    self.sunnylink_state = SunnylinkState()
+    op_services = self.sm.services
+    sp_services = [
+      "modelManagerSP", "selfdriveStateSP", "longitudinalPlanSP", "backupManagerSP",
+      "carControl", "gpsLocationExternal", "gpsLocation", "liveTorqueParameters",
+      "carStateSP", "liveParameters", "liveMapDataSP", "carParamsSP"
+    ]
+    self.sm = messaging.SubMaster(op_services + sp_services)
+
+    # Callbacks
+    self._ui_update_callbacks: list[Callable[[], None]] = []
+
+  def add_ui_update_callback(self, callback: Callable[[], None]):
+    self._ui_update_callbacks.append(callback)
+
+  def update(self) -> None:
+    UIState.update(self)
+    self.sunnylink_state.start()
+    for callback in self._ui_update_callbacks:
+      callback()
+
+  def _update_status(self) -> None:
+    UIState._update_status(self)
+
+  def update_params(self) -> None:
+    UIState.update_params(self)
+    self.sunnylink_enabled = self.params.get_bool("SunnylinkEnabled")
+
+# Global instance
+ui_state_sp = UIStateSP()

selfdrive/ui/ui.py

@@ -9,6 +9,8 @@ from openpilot.selfdrive.ui.layouts.main import MainLayout
 from openpilot.selfdrive.ui.mici.layouts.main import MiciMainLayout
 from openpilot.selfdrive.ui.ui_state import ui_state
 
+if gui_app.sunnypilot_ui():
+  from openpilot.selfdrive.ui.sunnypilot.ui_state import ui_state_sp as ui_state
 
 def main():
   cores = {5, }

sunnypilot/sunnylink/sunnylink_state.py

@@ -0,0 +1,195 @@
+from enum import IntEnum
+import threading
+import time
+import json
+
+from cereal import messaging
+from openpilot.common.params import Params
+from openpilot.common.swaglog import cloudlog
+from openpilot.sunnypilot.sunnylink.api import UNREGISTERED_SUNNYLINK_DONGLE_ID, SunnylinkApi
+
+
+class RoleType(IntEnum):
+  READONLY = 0
+  SPONSOR = 1
+  ADMIN = 2
+
+class SponsorTier(IntEnum):
+  FREE = 0
+  NOVICE = 1
+  SUPPORTER = 2
+  CONTRIBUTOR = 3
+  BENEFACTOR = 4
+  GUARDIAN = 5
+
+class User:
+  device_id: str
+  user_id: str
+  created_at: int
+  updated_at: int
+  token_hash: str
+
+  def __init__(self, json_data):
+    self.device_id = json_data.get("device_id")
+    self.user_id = json_data.get("user_id")
+    self.created_at = json_data.get("created_at")
+    self.updated_at = json_data.get("updated_at")
+    self.token_hash = json_data.get("token_hash")
+
+class Role:
+  role_type: str
+  role_tier: str
+
+  def __init__(self, json_data):
+    self.role_type = json_data.get("role_type")
+    self.role_tier = json_data.get("role_tier")
+
+def _parse_roles(roles: str) -> list[Role]:
+  lst_roles = []
+  try:
+    roles_list = json.loads(roles)
+    for r in roles_list:
+      try:
+        role = Role(r)
+        lst_roles.append(role)
+      except Exception as e:
+        cloudlog.exception(f"Failed to parse role {r}: {e}")
+    return lst_roles
+  except Exception as e:
+    cloudlog.exception(f"Error parsing roles: {e}")
+    return []
+
+
+def _parse_users(users: str) -> list[User]:
+  lst_users = []
+  try:
+    users_list = json.loads(users)
+    for u in users_list:
+      try:
+        user = User(u)
+        lst_users.append(user)
+      except Exception as e:
+        cloudlog.exception(f"Failed to parse user {u}: {e}")
+    return lst_users
+  except Exception as e:
+    cloudlog.exception(f"Error parsing users: {e}")
+    return []
+
+
+class SunnylinkState:
+  FETCH_INTERVAL = 5.0  # seconds between API calls
+  API_TIMEOUT = 10.0  # seconds for API requests
+  SLEEP_INTERVAL = 0.5  # seconds to sleep between checks in the worker thread
+  NOT_PAIRED_USERNAMES = ["unregisteredsponsor", "temporarysponsor"]
+
+  def __init__(self):
+    self._params = Params()
+    self._lock = threading.Lock()
+    self._running = False
+    self._thread = None
+    self._sm = messaging.SubMaster(['deviceState'])
+
+    self._roles: list[Role] = []
+    self._users: list[User] = []
+    self.sponsor_tier: SponsorTier = SponsorTier.FREE
+    self.sunnylink_dongle_id = self._params.get("SunnylinkDongleId")
+    self._api = SunnylinkApi(self.sunnylink_dongle_id)
+
+    self._load_initial_state()
+
+  def _load_initial_state(self) -> None:
+    roles_cache = self._params.get("SunnylinkCache_Roles")
+    users_cache = self._params.get("SunnylinkCache_Users")
+    if roles_cache is not None:
+      self._roles = _parse_roles(roles_cache)
+      self.sponsor_tier =  self._get_highest_tier()
+    if users_cache is not None:
+      self._users = _parse_users(users_cache)
+
+  def _get_highest_tier(self) -> SponsorTier:
+    role_tier = SponsorTier.FREE
+    for role in self._roles:
+      try:
+        if RoleType[role.role_type.upper()] == RoleType.SPONSOR:
+          role_tier = max(role_tier, SponsorTier[role.role_tier.upper()])
+      except Exception as e:
+        cloudlog.exception(f"Error parsing role {role}: {e} for dongle id {self.sunnylink_dongle_id}")
+    return role_tier
+
+  def _fetch_roles(self) -> None:
+    if not self.sunnylink_dongle_id or self.sunnylink_dongle_id == UNREGISTERED_SUNNYLINK_DONGLE_ID:
+      return
+
+    try:
+      token = self._api.get_token()
+      response = self._api.api_get(f"device/{self.sunnylink_dongle_id}/roles", method='GET', access_token=token)
+      if response.status_code == 200:
+        self._roles = _parse_roles(response.text)
+        self._params.put("SunnylinkCache_Roles", response.text)
+        sponsor_tier = self._get_highest_tier()
+        with self._lock:
+          if sponsor_tier != self.sponsor_tier:
+            self.sponsor_tier = sponsor_tier
+            cloudlog.info(f"Sunnylink sponsor tier updated to {sponsor_tier.name}")
+    except Exception as e:
+      cloudlog.exception(f"Failed to fetch sunnylink roles: {e} for dongle id {self.sunnylink_dongle_id}")
+
+  def _fetch_users(self) -> None:
+    if not self.sunnylink_dongle_id or self.sunnylink_dongle_id == UNREGISTERED_SUNNYLINK_DONGLE_ID:
+      return
+
+    try:
+      token = self._api.get_token()
+      response = self._api.api_get(f"device/{self.sunnylink_dongle_id}/users", method='GET', access_token=token)
+      if response.status_code == 200:
+        users = response.text
+        self._params.put("SunnylinkCache_Users", users)
+        with self._lock:
+          _parse_users(users)
+    except Exception as e:
+      cloudlog.exception(f"Failed to fetch sunnylink users: {e} for dongle id {self.sunnylink_dongle_id}")
+
+  def _worker_thread(self) -> None:
+    while self._running:
+      if self.is_connected():
+        self._fetch_roles()
+        self._fetch_users()
+
+      for _ in range(int(self.FETCH_INTERVAL / self.SLEEP_INTERVAL)):
+        if not self._running:
+          break
+        time.sleep(self.SLEEP_INTERVAL)
+
+  def start(self) -> None:
+    if self._thread and self._thread.is_alive():
+      return
+    self._running = True
+    self._thread = threading.Thread(target=self._worker_thread, daemon=True)
+    self._thread.start()
+
+  def stop(self) -> None:
+    self._running = False
+    if self._thread and self._thread.is_alive():
+      self._thread.join(timeout=1.0)
+
+  def get_sponsor_tier(self) -> SponsorTier:
+    with self._lock:
+      return self.sponsor_tier
+
+  def is_sponsor(self) -> bool:
+    with self._lock:
+      is_sponsor =  any(role.role_type.upper() == RoleType.SPONSOR.name and role.role_tier.upper() != SponsorTier.FREE.name
+                        for role in self._roles)
+      return is_sponsor
+
+  def is_paired(self) -> bool:
+    with self._lock:
+      is_paired = any(user.user_id not in self.NOT_PAIRED_USERNAMES for user in self._users)
+      return is_paired
+
+  def is_connected(self) -> bool:
+    network_type = self._sm["deviceState"].networkType
+    return bool(network_type != 0)
+
+  def __del__(self):
+    self.stop()

system/ui/lib/scroll_panel.py

@@ -41,12 +41,8 @@ class GuiScrollPanel:
     if DEBUG:
       rl.draw_rectangle_lines(0, 0, abs(int(self._velocity_filter_y.x)), 10, rl.RED)
 
-    # Handle mouse wheel only when the mouse cursor is over this panel
-    mouse_wheel = rl.get_mouse_wheel_move()
-    if mouse_wheel != 0:
-      mouse_pos = rl.get_mouse_position()
-      if rl.check_collision_point_rec(mouse_pos, bounds):
-        self._offset_filter_y.x += mouse_wheel * MOUSE_WHEEL_SCROLL_SPEED
+    # Handle mouse wheel
+    self._offset_filter_y.x += rl.get_mouse_wheel_move() * MOUSE_WHEEL_SCROLL_SPEED
 
     max_scroll_distance = max(0, content.height - bounds.height)
     if self._scroll_state == ScrollState.IDLE:

system/ui/sunnypilot/lib/styles.py

@@ -17,7 +17,6 @@ class Base:
   ITEM_TEXT_FONT_SIZE = 50
   ITEM_DESC_FONT_SIZE = 40
   ITEM_DESC_V_OFFSET = 150
-  CLOSE_BTN_SIZE = 160
 
   # Toggle Control
   TOGGLE_HEIGHT = 120
@@ -30,7 +29,7 @@ class DefaultStyleSP(Base):
   # Base Colors
   BASE_BG_COLOR = rl.Color(57, 57, 57, 255)  # Grey
   ON_BG_COLOR = rl.Color(28, 101, 186, 255)  # Blue
-  OFF_BG_COLOR = BASE_BG_COLOR
+  OFF_BG_COLOR = rl.Color(70, 70, 70, 255)  # Lighter Grey
   ON_HOVER_BG_COLOR = rl.Color(17, 78, 150, 255)  # Dark Blue
   OFF_HOVER_BG_COLOR = rl.Color(21, 21, 21, 255)  # Dark gray
   DISABLED_ON_BG_COLOR = rl.Color(37, 70, 107, 255)  # Dull Blue

system/ui/sunnypilot/widgets/helpers/fuzzy_search.py

@@ -1,34 +0,0 @@
-import re
-import unicodedata
-
-
-def normalize(text: str) -> str:
-  return unicodedata.normalize('NFKD', text).encode('ascii', 'ignore').decode('utf-8').lower()
-
-
-def search_from_list(query: str, items: list[str]) -> list[str]:
-  if not query:
-    return items
-
-  normalized_query = normalize(query)
-  search_terms = [re.sub(r'[^a-z0-9]', '', term) for term in normalized_query.split() if term.strip()]
-
-  results = []
-  for item in items:
-    normalized_item = normalize(item)
-    item_with_spaces = re.sub(r'[^a-z0-9\s]', ' ', normalized_item)
-    item_stripped = re.sub(r'[^a-z0-9]', '', normalized_item)
-
-    all_terms_match = True
-    for term in search_terms:
-      if not term:
-        continue
-
-      if term not in item_with_spaces and term not in item_stripped:
-        all_terms_match = False
-        break
-
-    if all_terms_match:
-      results.append(item)
-
-  return results

system/ui/sunnypilot/widgets/input_dialog.py

@@ -1,35 +0,0 @@
-from collections.abc import Callable
-
-from openpilot.common.params import Params
-from openpilot.system.ui.lib.application import gui_app
-from openpilot.system.ui.lib.multilang import tr
-from openpilot.system.ui.widgets import DialogResult
-from openpilot.system.ui.widgets.keyboard import Keyboard
-
-
-class InputDialogSP:
-  def __init__(self, title: str, sub_title: str | None = None, current_text: str = "", param: str | None = None,
-               callback: Callable[[DialogResult, str], None] | None = None,
-               min_text_size: int = 0, password_mode: bool = False):
-    self.callback = callback
-    self.current_text = current_text
-    self.keyboard = Keyboard(max_text_size=255, min_text_size=min_text_size, password_mode=password_mode)
-    self.param = param
-    self._params = Params()
-    self.sub_title = sub_title
-    self.title = title
-
-  def show(self):
-    self.keyboard.reset(min_text_size=self.keyboard._min_text_size)
-    self.keyboard.set_title(tr(self.title), *(tr(self.sub_title),) if self.sub_title else ())
-    self.keyboard.set_text(self.current_text)
-
-    def internal_callback(result: DialogResult):
-      text = self.keyboard.text if result == DialogResult.CONFIRM else ""
-      if result == DialogResult.CONFIRM:
-        if self.param:
-          self._params.put(self.param, text)
-      if self.callback:
-        self.callback(result, text)
-
-    gui_app.set_modal_overlay(self.keyboard, internal_callback)

system/ui/sunnypilot/widgets/sunnylink_pairing_dialog.py

@@ -0,0 +1,130 @@
+import base64
+
+import pyray as rl
+from openpilot.common.swaglog import cloudlog
+from openpilot.selfdrive.ui.sunnypilot.ui_state import ui_state_sp
+from openpilot.selfdrive.ui.widgets.pairing_dialog import PairingDialog
+from openpilot.sunnypilot.sunnylink.api import SunnylinkApi, UNREGISTERED_SUNNYLINK_DONGLE_ID, API_HOST
+from openpilot.system.ui.lib.application import FontWeight, gui_app
+from openpilot.system.ui.lib.multilang import tr
+from openpilot.system.ui.lib.wrap_text import wrap_text
+from openpilot.system.ui.lib.text_measure import measure_text_cached
+
+
+class SunnylinkPairingDialog(PairingDialog):
+  """Dialog for device pairing with QR code."""
+
+  QR_REFRESH_INTERVAL = 300  # 5 minutes in seconds
+
+  def __init__(self, sponsor_pairing: bool = False):
+    PairingDialog.__init__(self)
+    self._sponsor_pairing = sponsor_pairing
+
+  def _get_pairing_url(self) -> str:
+    qr_string = "https://github.com/sponsors/sunnyhaibin"
+
+    if self._sponsor_pairing:
+      try:
+        sl_dongle_id = self.params.get("SunnylinkDongleId") or UNREGISTERED_SUNNYLINK_DONGLE_ID
+        token = SunnylinkApi(sl_dongle_id).get_token()
+        inner_string = f"1|{sl_dongle_id}|{token}"
+        payload_bytes = base64.b64encode(inner_string.encode('utf-8')).decode('utf-8')
+        qr_string = f"{API_HOST}/sso?state={payload_bytes}"
+      except Exception:
+        cloudlog.exception("Failed to get pairing token")
+
+    return qr_string
+
+  def _update_state(self):
+    if ui_state_sp.sunnylink_state.is_paired():
+      gui_app.set_modal_overlay(None)
+
+  def _render(self, rect: rl.Rectangle) -> int:
+    rl.clear_background(rl.Color(224, 224, 224, 255))
+
+    self._check_qr_refresh()
+
+    margin = 70
+    content_rect = rl.Rectangle(rect.x + margin, rect.y + margin, rect.width - 2 * margin, rect.height - 2 * margin)
+    y = content_rect.y
+
+    # Close button
+    close_size = 80
+    pad = 20
+    close_rect = rl.Rectangle(content_rect.x - pad, y - pad, close_size + pad * 2, close_size + pad * 2)
+    self._close_btn.render(close_rect)
+
+    y += close_size + 40
+
+    # Title
+    title = tr("Pair your GitHub account") if self._sponsor_pairing else tr("Early Access: Become a sunnypilot Sponsor")
+    title_font = gui_app.font(FontWeight.NORMAL)
+    left_width = int(content_rect.width * 0.5 - 15)
+
+    title_wrapped = wrap_text(title_font, title, 75, left_width)
+    rl.draw_text_ex(title_font, "\n".join(title_wrapped), rl.Vector2(content_rect.x, y), 75, 0.0, rl.BLACK)
+    y += len(title_wrapped) * 75 + 60
+
+    # Two columns: instructions and QR code
+    remaining_height = content_rect.height - (y - content_rect.y)
+    right_width = content_rect.width // 2 - 20
+
+    # Instructions
+    self._render_instructions(rl.Rectangle(content_rect.x, y, left_width, remaining_height))
+
+    # QR code
+    qr_size = min(right_width, content_rect.height) - 40
+    qr_x = content_rect.x + left_width + 40 + (right_width - qr_size) // 2
+    qr_y = content_rect.y
+    self._render_qr_code(rl.Rectangle(qr_x, qr_y, qr_size, qr_size))
+
+    return -1
+
+  def _render_instructions(self, rect: rl.Rectangle) -> None:
+    if self._sponsor_pairing:
+      instructions = [
+        tr("Scan the QR code to login to your GitHub account"),
+        tr("Follow the prompts to complete the pairing process"),
+        tr("Re-enter the \"sunnylink\" panel to verify sponsorship status"),
+        tr("If sponsorship status was not updated, please contact a moderator on our forum at https://community.sunnypilot.ai")
+      ]
+    else:
+      instructions = [
+        tr("Scan the QR code to visit sunnyhaibin's GitHub Sponsors page"),
+        tr("Choose your sponsorship tier and confirm your support"),
+        tr("Join our Community Forum at https://community.sunnypilot.ai and reach out to a moderator if you have issues")
+      ]
+
+    font = gui_app.font(FontWeight.BOLD)
+    y = rect.y
+
+    for i, text in enumerate(instructions):
+      circle_radius = 25
+      circle_x = rect.x + circle_radius + 15
+      text_x = rect.x + circle_radius * 2 + 40
+      text_width = rect.width - (circle_radius * 2 + 40)
+
+      wrapped = wrap_text(font, text, 47, int(text_width))
+      text_height = len(wrapped) * 47
+      circle_y = y + text_height // 2
+
+      # Circle and number
+      rl.draw_circle(int(circle_x), int(circle_y), circle_radius, rl.Color(70, 70, 70, 255))
+      number = str(i + 1)
+      number_size = measure_text_cached(font, number, 30)
+      rl.draw_text_ex(font, number, (int(circle_x - number_size.x // 2), int(circle_y - number_size.y // 2)), 30, 0, rl.WHITE)
+
+      # Text
+      rl.draw_text_ex(font, "\n".join(wrapped), rl.Vector2(text_x, y), 47, 0.0, rl.BLACK)
+      y += text_height + 50
+
+if __name__ == "__main__":
+  gui_app.init_window("pairing device")
+  pairing = SunnylinkPairingDialog(sponsor_pairing=True)
+  try:
+    for _ in gui_app.render():
+      result = pairing.render(rl.Rectangle(0, 0, gui_app.width, gui_app.height))
+      if result != -1:
+        break
+  finally:
+    del pairing

system/ui/sunnypilot/widgets/tests/test_input_dialog.py

@@ -1,58 +0,0 @@
-import os
-import pytest
-
-from openpilot.common.params import Params
-from openpilot.system.ui.lib.application import gui_app
-from openpilot.system.ui.widgets.keyboard import Keyboard
-from openpilot.system.ui.sunnypilot.widgets.input_dialog import InputDialogSP
-
-os.environ['SDL_VIDEODRIVER'] = 'dummy'
-if not os.environ.get('CI'):
-  pytest.skip("Test in CI environment, or comment out this flag to test locally", allow_module_level=True)
-
-
-class TestInputDialog:
-  def setup_method(self):
-    self.params = Params()
-
-  def test_input_dialog_int(self):
-    gui_app.init_window("test window")
-    dialog = InputDialogSP("title", current_text="current_text", param="MapTargetVelocities")
-    dialog.show()
-
-    dialog.keyboard._render_return_status = 1
-    gui_app._handle_modal_overlay()
-
-    assert self.params.get("MapTargetVelocities") == "current_text"
-
-  def test_before_input_dialog(self):
-    gui_app.init_window("test window")
-    current_apn = "gsmapn"
-    # This tests the pre InputDialogSP, where keyboard setup had to be done for every single dialog box you want to use.
-    self.keyboard = Keyboard()
-    self.keyboard.reset(min_text_size=0)
-    self.keyboard.set_title(("Enter APN"), ("networking"))
-    self.keyboard.set_text(current_apn)
-
-    def pre_input_dialog_callback(result):
-      if result == 1:
-        apn = self.keyboard.text.strip()
-        self.params.put("GsmApn", apn)
-
-    gui_app.set_modal_overlay(self.keyboard, pre_input_dialog_callback)
-    self.keyboard.set_text("new_apn")
-    self.keyboard._render_return_status = 1
-    gui_app._handle_modal_overlay()
-    pre_input_dialog_result = self.params.get("GsmApn")
-
-    assert pre_input_dialog_result == "new_apn"
-
-    dialog = InputDialogSP(title="Enter APN", sub_title="networking", current_text=current_apn, param="GsmApn")
-    dialog.show()
-    dialog.keyboard.set_text("new_apn")
-    dialog.keyboard._render_return_status = 1
-    gui_app._handle_modal_overlay()
-    input_dialog_result = self.params.get("GsmApn")
-
-    assert input_dialog_result == "new_apn"
-    assert pre_input_dialog_result == input_dialog_result

system/ui/widgets/scroller.py

@@ -28,8 +28,8 @@ class LineSeparator(Widget):
     self._rect.width = parent_rect.width
 
   def _render(self, _):
-    rl.draw_line(int(self._rect.x) + LINE_PADDING, int(self._rect.y),
-                 int(self._rect.x + self._rect.width) - LINE_PADDING, int(self._rect.y),
+    rl.draw_line(int(self._rect.x), int(self._rect.y),
+                 int(self._rect.x + self._rect.width), int(self._rect.y),
                  LINE_COLOR)