Merge branch 'master' into navigationd-init

This reverts commit 3bbb33f6bd.

.github/workflows/tests.yaml

@@ -21,11 +21,12 @@ env:
   PYTHONWARNINGS: error
   BASE_IMAGE: sunnypilot-base
   AZURE_TOKEN: ${{ secrets.AZURE_COMMADATACI_OPENPILOTCI_TOKEN }}
+  MAPBOX_TOKEN_CI: ${{ secrets.MAPBOX_TOKEN_CI }}
 
   DOCKER_LOGIN: docker login ghcr.io -u ${{ github.actor }} -p ${{ secrets.GITHUB_TOKEN }}
   BUILD: release/ci/docker_build_sp.sh base
 
-  RUN: docker run --shm-size 2G -v $PWD:/tmp/openpilot -w /tmp/openpilot -e CI=1 -e PYTHONWARNINGS=error -e FILEREADER_CACHE=1 -e PYTHONPATH=/tmp/openpilot -e NUM_JOBS -e JOB_ID -e GITHUB_ACTION -e GITHUB_REF -e GITHUB_HEAD_REF -e GITHUB_SHA -e GITHUB_REPOSITORY -e GITHUB_RUN_ID -v $GITHUB_WORKSPACE/.ci_cache/scons_cache:/tmp/scons_cache -v $GITHUB_WORKSPACE/.ci_cache/comma_download_cache:/tmp/comma_download_cache -v $GITHUB_WORKSPACE/.ci_cache/openpilot_cache:/tmp/openpilot_cache $BASE_IMAGE /bin/bash -c
+  RUN: docker run --shm-size 2G -v $PWD:/tmp/openpilot -w /tmp/openpilot -e CI=1 -e PYTHONWARNINGS=error -e FILEREADER_CACHE=1 -e PYTHONPATH=/tmp/openpilot -e NUM_JOBS -e JOB_ID -e GITHUB_ACTION -e GITHUB_REF -e GITHUB_HEAD_REF -e GITHUB_SHA -e GITHUB_REPOSITORY -e GITHUB_RUN_ID -e MAPBOX_TOKEN_CI=$MAPBOX_TOKEN_CI -v $GITHUB_WORKSPACE/.ci_cache/scons_cache:/tmp/scons_cache -v $GITHUB_WORKSPACE/.ci_cache/comma_download_cache:/tmp/comma_download_cache -v $GITHUB_WORKSPACE/.ci_cache/openpilot_cache:/tmp/openpilot_cache $BASE_IMAGE /bin/bash -c
 
   PYTEST: pytest --continue-on-collection-errors --durations=0 -n logical
 

common/params_keys.h

@@ -189,6 +189,11 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"ModelManager_LastSyncTime", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, INT, "0"}},
     {"ModelManager_ModelsCache", {PERSISTENT | BACKUP, JSON}},
 
+    // Navigation params
+    {"MapboxToken", {PERSISTENT | BACKUP, STRING}},
+    {"MapboxSettings", {CLEAR_ON_MANAGER_START, JSON}},
+    {"MapboxRoute", {CLEAR_ON_MANAGER_START, STRING}},
+
     // Neural Network Lateral Control
     {"NeuralNetworkLateralControl", {PERSISTENT | BACKUP, BOOL, "0"}},
 

selfdrive/ui/layouts/main.py

@@ -10,8 +10,6 @@ from openpilot.selfdrive.ui.ui_state import device, ui_state
 from openpilot.system.ui.widgets import Widget
 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

selfdrive/ui/mici/layouts/home.py

@@ -118,9 +118,6 @@ 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.sunnypilot.mici.layouts.settings import SettingsLayoutSP as SettingsLayout
+from openpilot.selfdrive.ui.mici.layouts.settings.settings import 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,24 +0,0 @@
-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):
-  def __init__(self):
-    super().__init__()
-
-    self._params = Params()
-    items = self._initialize_items()
-    self._scroller = Scroller(items, line_separator=True, spacing=0)
-
-  def _initialize_items(self):
-
-    items = [
-    ]
-    return items
-
-  def _render(self, rect):
-    self._scroller.render(rect)
-
-  def show_event(self):
-    self._scroller.show_event()

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

@@ -1,5 +0,0 @@
-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,24 +0,0 @@
-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):
-  def __init__(self):
-    super().__init__()
-
-    self._params = Params()
-    items = self._initialize_items()
-    self._scroller = Scroller(items, line_separator=True, spacing=0)
-
-  def _initialize_items(self):
-    items = [
-
-    ]
-    return items
-
-  def _render(self, rect):
-    self._scroller.render(rect)
-
-  def show_event(self):
-    self._scroller.show_event()

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

@@ -1,24 +0,0 @@
-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):
-  def __init__(self):
-    super().__init__()
-
-    self._params = Params()
-    items = self._initialize_items()
-    self._scroller = Scroller(items, line_separator=True, spacing=0)
-
-  def _initialize_items(self):
-    items = [
-
-    ]
-    return items
-
-  def _render(self, rect):
-    self._scroller.render(rect)
-
-  def show_event(self):
-    self._scroller.show_event()

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

@@ -1,24 +0,0 @@
-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):
-  def __init__(self):
-    super().__init__()
-
-    self._params = Params()
-    items = self._initialize_items()
-    self._scroller = Scroller(items, line_separator=True, spacing=0)
-
-  def _initialize_items(self):
-    items = [
-
-    ]
-    return items
-
-  def _render(self, rect):
-    self._scroller.render(rect)
-
-  def show_event(self):
-    self._scroller.show_event()

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

@@ -1,24 +0,0 @@
-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):
-  def __init__(self):
-    super().__init__()
-
-    self._params = Params()
-    items = self._initialize_items()
-    self._scroller = Scroller(items, line_separator=True, spacing=0)
-
-  def _initialize_items(self):
-    items = [
-
-    ]
-    return items
-
-  def _render(self, rect):
-    self._scroller.render(rect)
-
-  def show_event(self):
-    self._scroller.show_event()

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

@@ -1,189 +0,0 @@
-import pyray as rl
-from dataclasses import dataclass
-from enum import IntEnum
-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.multilang import tr_noop
-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
-from openpilot.system.ui.lib.wifi_manager import WifiManager
-from openpilot.system.ui.widgets import Widget
-from openpilot.selfdrive.ui.sunnypilot.layouts.settings.models import ModelsLayout
-from openpilot.selfdrive.ui.sunnypilot.layouts.settings.sunnylink import SunnylinkLayout
-from openpilot.selfdrive.ui.sunnypilot.layouts.settings.osm import OSMLayout
-from openpilot.selfdrive.ui.sunnypilot.layouts.settings.trips import TripsLayout
-from openpilot.selfdrive.ui.sunnypilot.layouts.settings.vehicle import VehicleLayout
-from openpilot.selfdrive.ui.sunnypilot.layouts.settings.steering import SteeringLayout
-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
-
-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",
-    "MODELS",
-    "STEERING",
-    "CRUISE",
-    "VISUALS",
-    "DISPLAY",
-    "OSM",
-    "NAVIGATION",
-    "TRIPS",
-    "VEHICLE",
-  ],
-  start=0,
-  )
-
-@dataclass
-class PanelInfo(OP.PanelInfo):
-  icon: str = ""
-
-
-class SettingsLayoutSP(OP.SettingsLayout):
-  def __init__(self):
-    OP.SettingsLayout.__init__(self)
-    self._nav_items: list[Widget] = []
-
-    # Create sidebar scroller
-    self._sidebar_scroller = Scroller([], spacing=0, line_separator = False, pad_end=False)
-
-    # Panel configuration
-    wifi_manager = WifiManager()
-    wifi_manager.set_active(False)
-
-    self._panels = {
-      OP.PanelType.DEVICE: PanelInfo(tr_noop("Device"), DeviceLayoutSP(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_home.png"),
-      OP.PanelType.NETWORK: PanelInfo(tr_noop("Network"), NetworkUI(wifi_manager), icon="icons/network.png"),
-      OP.PanelType.SUNNYLINK: PanelInfo(tr_noop("sunnylink"), SunnylinkLayout(), icon="icons/shell.png"),
-      OP.PanelType.TOGGLES: PanelInfo(tr_noop("Toggles"), TogglesLayout(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_toggle.png"),
-      OP.PanelType.SOFTWARE: PanelInfo(tr_noop("Software"), SoftwareLayout(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_software.png"),
-      OP.PanelType.MODELS: PanelInfo(tr_noop("Models"), ModelsLayout(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_models.png"),
-      OP.PanelType.STEERING: PanelInfo(tr_noop("Steering"), SteeringLayout(), icon="../../sunnypilot/selfdrive/assets/offroad/icon_lateral.png"),
-      OP.PanelType.CRUISE: PanelInfo(tr_noop("Cruise"), CruiseLayout(), icon="icons/speed_limit.png"),
-      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.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"),
-      OP.PanelType.DEVELOPER: PanelInfo(tr_noop("Developer"), DeveloperLayout(), icon="icons/shell.png"),
-    }
-
-  def _create_nav_button(self, panel_type: OP.PanelType, panel_info: PanelInfo) -> Widget:
-    class NavButton(Widget):
-      def __init__(self, parent, p_type, p_info):
-        super().__init__()
-        self.parent = parent
-        self.panel_type = p_type
-        self.panel_info = p_info
-
-      def _render(self, rect):
-        is_selected = self.panel_type == self.parent._current_panel
-        text_color = OP.TEXT_SELECTED if is_selected else OP.TEXT_NORMAL
-        content_x = rect.x + 90
-        text_size = measure_text_cached(self.parent._font_medium, self.panel_info.name, 65)
-
-        # Draw background if selected
-        if is_selected:
-          self.container_rect = rl.Rectangle(
-            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)
-
-        if self.panel_info.icon:
-          icon_texture = gui_app.texture(self.panel_info.icon, ICON_SIZE, ICON_SIZE, keep_aspect_ratio=True)
-          rl.draw_texture(icon_texture, int(content_x), int(rect.y + (OP.NAV_BTN_HEIGHT - icon_texture.height) / 2), rl.WHITE)
-          content_x += ICON_SIZE + 20
-
-        # Draw button text (right-aligned)
-        text_pos = rl.Vector2(
-          content_x,
-          rect.y + (OP.NAV_BTN_HEIGHT - text_size.y) / 2
-        )
-        rl.draw_text_ex(self.parent._font_medium, self.panel_info.name, text_pos, 55, 0, text_color)
-
-        # Store button rect for click detection
-        self.panel_info.button_rect = rect
-
-    return NavButton(self, panel_type, panel_info)
-
-  def _draw_sidebar(self, rect: rl.Rectangle):
-    rl.draw_rectangle_rec(rect, OP.SIDEBAR_COLOR)
-
-    # Close button
-    close_btn_rect = rl.Rectangle(
-      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
-               rl.check_collision_point_rec(rl.get_mouse_position(), close_btn_rect))
-    close_color = OP.CLOSE_BTN_PRESSED if pressed else OP.CLOSE_BTN_COLOR
-    rl.draw_rectangle_rounded(close_btn_rect, 1.0, 20, close_color)
-
-    icon_color = rl.Color(255, 255, 255, 255) if not pressed else rl.Color(220, 220, 220, 255)
-    icon_dest = rl.Rectangle(
-      close_btn_rect.x + (close_btn_rect.width - self._close_icon.width) / 2,
-      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),
-      icon_dest,
-      rl.Vector2(0, 0),
-      0,
-      icon_color,
-    )
-
-    # Store close button rect for click detection
-    self._close_btn_rect = close_btn_rect
-
-    # Navigation buttons with scroller
-    if not self._nav_items:
-      for panel_type, panel_info in self._panels.items():
-        nav_button = self._create_nav_button(panel_type, panel_info)
-        nav_button.rect.width = rect.width - 100  # Full width minus padding
-        nav_button.rect.height = OP.NAV_BTN_HEIGHT
-        self._nav_items.append(nav_button)
-        self._sidebar_scroller.add_widget(nav_button)
-
-    # Draw navigation section with scroller
-    nav_rect = rl.Rectangle(
-      rect.x,
-      rect.y + 300,  # Starting Y position for nav items
-      rect.width,
-      rect.height - 300  # Remaining height after close button
-    )
-
-    if self._nav_items:
-      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):
-      if self._close_callback:
-        self._close_callback()
-      return True
-
-    # Check navigation buttons
-    for panel_type, panel_info in self._panels.items():
-      if rl.check_collision_point_rec(mouse_pos, panel_info.button_rect) and self._sidebar_scroller.scroll_panel.is_touch_valid():
-        self.set_current_panel(panel_type)
-        return True
-
-    return False

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

@@ -1,24 +0,0 @@
-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):
-  def __init__(self):
-    super().__init__()
-
-    self._params = Params()
-    items = self._initialize_items()
-    self._scroller = Scroller(items, line_separator=True, spacing=0)
-
-  def _initialize_items(self):
-    items = [
-
-    ]
-    return items
-
-  def _render(self, rect):
-    self._scroller.render(rect)
-
-  def show_event(self):
-    self._scroller.show_event()

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

@@ -1,181 +0,0 @@
-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, DialogResult
-from openpilot.common.params import Params
-from openpilot.system.ui.sunnypilot.widgets.list_view import toggle_item_sp
-
-
-class SunnylinkLayout(Widget):
-  def __init__(self):
-    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):
-    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)
-
-  def show_event(self):
-    self._scroller.show_event()

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

@@ -1,24 +0,0 @@
-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):
-  def __init__(self):
-    super().__init__()
-
-    self._params = Params()
-    items = self._initialize_items()
-    self._scroller = Scroller(items, line_separator=True, spacing=0)
-
-  def _initialize_items(self):
-    items = [
-
-    ]
-    return items
-
-  def _render(self, rect):
-    self._scroller.render(rect)
-
-  def show_event(self):
-    self._scroller.show_event()

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

@@ -1,24 +0,0 @@
-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):
-  def __init__(self):
-    super().__init__()
-
-    self._params = Params()
-    items = self._initialize_items()
-    self._scroller = Scroller(items, line_separator=True, spacing=0)
-
-  def _initialize_items(self):
-    items = [
-
-    ]
-    return items
-
-  def _render(self, rect):
-    self._scroller.render(rect)
-
-  def show_event(self):
-    self._scroller.show_event()

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

@@ -1,24 +0,0 @@
-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):
-  def __init__(self):
-    super().__init__()
-
-    self._params = Params()
-    items = self._initialize_items()
-    self._scroller = Scroller(items, line_separator=True, spacing=0)
-
-  def _initialize_items(self):
-    items = [
-
-    ]
-    return items
-
-  def _render(self, rect):
-    self._scroller.render(rect)
-
-  def show_event(self):
-    self._scroller.show_event()

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

@@ -1,40 +0,0 @@
-"""
-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

@@ -1,170 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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/tests/test_ui/raylib_screenshots.py

@@ -41,47 +41,47 @@ def put_update_params(params: Params):
   params.put("UpdaterTargetBranch", BRANCH_NAME)
 
 
-def setup_homescreen(click, pm: PubMaster, scroll=None):
+def setup_homescreen(click, pm: PubMaster):
   pass
 
 
-def setup_homescreen_update_available(click, pm: PubMaster, scroll=None):
+def setup_homescreen_update_available(click, pm: PubMaster):
   params = Params()
   params.put_bool("UpdateAvailable", True)
   put_update_params(params)
   setup_offroad_alert(click, pm)
 
 
-def setup_settings(click, pm: PubMaster, scroll=None):
+def setup_settings(click, pm: PubMaster):
   click(100, 100)
 
 
-def close_settings(click, pm: PubMaster, scroll=None):
+def close_settings(click, pm: PubMaster):
   click(240, 216)
 
 
-def setup_settings_network(click, pm: PubMaster, scroll=None):
+def setup_settings_network(click, pm: PubMaster):
   setup_settings(click, pm)
   click(278, 450)
 
 
-def setup_settings_network_advanced(click, pm: PubMaster, scroll=None):
-  setup_settings_network(click, pm, scroll=scroll)
+def setup_settings_network_advanced(click, pm: PubMaster):
+  setup_settings_network(click, pm)
   click(1880, 100)
 
 
-def setup_settings_toggles(click, pm: PubMaster, scroll=None):
+def setup_settings_toggles(click, pm: PubMaster):
+  setup_settings(click, pm)
+  click(278, 600)
+
+
+def setup_settings_software(click, pm: PubMaster):
+  put_update_params(Params())
   setup_settings(click, pm)
   click(278, 720)
 
 
-def setup_settings_software(click, pm: PubMaster, scroll=None):
-  put_update_params(Params())
-  setup_settings(click, pm)
-  click(278, 845)
-
-
-def setup_settings_software_download(click, pm: PubMaster, scroll=None):
+def setup_settings_software_download(click, pm: PubMaster):
   params = Params()
   # setup_settings_software but with "DOWNLOAD" button to test long text
   params.put("UpdaterState", "idle")
@@ -89,13 +89,13 @@ def setup_settings_software_download(click, pm: PubMaster, scroll=None):
   setup_settings_software(click, pm)
 
 
-def setup_settings_software_release_notes(click, pm: PubMaster, scroll=None):
-  setup_settings_software(click, pm, scroll=scroll)
+def setup_settings_software_release_notes(click, pm: PubMaster):
+  setup_settings_software(click, pm)
   click(588, 110)  # expand description for current version
 
 
-def setup_settings_software_branch_switcher(click, pm: PubMaster, scroll=None):
-  setup_settings_software(click, pm, scroll=scroll)
+def setup_settings_software_branch_switcher(click, pm: PubMaster):
+  setup_settings_software(click, pm)
   params = Params()
   params.put("UpdaterAvailableBranches", f"master,nightly,release,{BRANCH_NAME}")
   params.put("GitBranch", BRANCH_NAME)  # should be on top
@@ -103,32 +103,30 @@ def setup_settings_software_branch_switcher(click, pm: PubMaster, scroll=None):
   click(1984, 449)
 
 
-def setup_settings_firehose(click, pm: PubMaster, scroll=None):
+def setup_settings_firehose(click, pm: PubMaster):
   setup_settings(click, pm)
-  scroll(-1000, 278, 950)
-  click(278, 950)
+  click(278, 845)
 
 
-def setup_settings_developer(click, pm: PubMaster, scroll=None):
+def setup_settings_developer(click, pm: PubMaster):
   CP = car.CarParams()
   CP.alphaLongitudinalAvailable = True  # show alpha long control toggle
   Params().put("CarParamsPersistent", CP.to_bytes())
 
   setup_settings(click, pm)
-  scroll(-1000, 278, 950)
-  click(278, 1040)
+  click(278, 950)
 
 
-def setup_keyboard(click, pm: PubMaster, scroll=None):
-  setup_settings_developer(click, pm, scroll=scroll)
+def setup_keyboard(click, pm: PubMaster):
+  setup_settings_developer(click, pm)
   click(1930, 470)
 
 
-def setup_pair_device(click, pm: PubMaster, scroll=None):
+def setup_pair_device(click, pm: PubMaster):
   click(1950, 800)
 
 
-def setup_offroad_alert(click, pm: PubMaster, scroll=None):
+def setup_offroad_alert(click, pm: PubMaster):
   put_update_params(Params())
   set_offroad_alert("Offroad_TemperatureTooHigh", True, extra_text='99C')
   set_offroad_alert("Offroad_ExcessiveActuation", True, extra_text='longitudinal')
@@ -139,63 +137,22 @@ def setup_offroad_alert(click, pm: PubMaster, scroll=None):
   close_settings(click, pm)
 
 
-def setup_confirmation_dialog(click, pm: PubMaster, scroll=None):
+def setup_confirmation_dialog(click, pm: PubMaster):
   setup_settings(click, pm)
   click(1985, 791)  # reset calibration
 
 
-def setup_experimental_mode_description(click, pm: PubMaster, scroll=None):
+def setup_experimental_mode_description(click, pm: PubMaster):
   setup_settings_toggles(click, pm)
   click(1200, 280)  # expand description for experimental mode
 
 
-def setup_openpilot_long_confirmation_dialog(click, pm: PubMaster, scroll=None):
-  setup_settings_developer(click, pm, scroll=scroll)
+def setup_openpilot_long_confirmation_dialog(click, pm: PubMaster):
+  setup_settings_developer(click, pm)
   click(650, 960)  # toggle openpilot longitudinal control
 
-def setup_settings_sunnylink(click, pm: PubMaster, scroll=None):
-  setup_settings(click, pm)
-  click(278, 600)
 
-def setup_settings_models(click, pm: PubMaster, scroll=None):
-  setup_settings(click, pm)
-  click(278, 950)
-
-def setup_settings_steering(click, pm: PubMaster, scroll=None):
-  setup_settings(click, pm)
-  click(278, 1040)
-
-def setup_settings_cruise(click, pm: PubMaster, scroll=None):
-  setup_settings(click, pm)
-  scroll(-40, 278, 950)
-  click(278, 1040)
-
-def setup_settings_visuals(click, pm: PubMaster, scroll=None):
-  setup_settings(click, pm)
-  scroll(-1000, 278, 950)
-  click(278, 330)
-
-def setup_settings_display(click, pm: PubMaster, scroll=None):
-  setup_settings(click, pm)
-  scroll(-1000, 278, 950)
-  click(278, 450)
-
-def setup_settings_osm(click, pm: PubMaster, scroll=None):
-  setup_settings(click, pm)
-  scroll(-1000, 278, 950)
-  click(278, 600)
-
-def setup_settings_trips(click, pm: PubMaster, scroll=None):
-  setup_settings(click, pm)
-  scroll(-1000, 278, 950)
-  click(278, 720)
-
-def setup_settings_vehicle(click, pm: PubMaster, scroll=None):
-  setup_settings(click, pm)
-  scroll(-1000, 278, 950)
-  click(278, 845)
-
-def setup_onroad(click, pm: PubMaster, scroll=None):
+def setup_onroad(click, pm: PubMaster):
   ds = messaging.new_message('deviceState')
   ds.deviceState.started = True
 
@@ -216,7 +173,7 @@ def setup_onroad(click, pm: PubMaster, scroll=None):
     time.sleep(0.05)
 
 
-def setup_onroad_sidebar(click, pm: PubMaster, scroll=None):
+def setup_onroad_sidebar(click, pm: PubMaster):
   setup_onroad(click, pm)
   click(100, 100)  # open sidebar
 
@@ -235,23 +192,23 @@ def setup_onroad_alert(click, pm: PubMaster, size: log.SelfdriveState.AlertSize,
     time.sleep(0.05)
 
 
-def setup_onroad_small_alert(click, pm: PubMaster, scroll=None):
+def setup_onroad_small_alert(click, pm: PubMaster):
   setup_onroad_alert(click, pm, AlertSize.small, "Small Alert", "This is a small alert", AlertStatus.normal)
 
 
-def setup_onroad_medium_alert(click, pm: PubMaster, scroll=None):
+def setup_onroad_medium_alert(click, pm: PubMaster):
   setup_onroad_alert(click, pm, AlertSize.mid, "Medium Alert", "This is a medium alert", AlertStatus.userPrompt)
 
 
-def setup_onroad_full_alert(click, pm: PubMaster, scroll=None):
+def setup_onroad_full_alert(click, pm: PubMaster):
   setup_onroad_alert(click, pm, AlertSize.full, "DISENGAGE IMMEDIATELY", "Driver Distracted", AlertStatus.critical)
 
 
-def setup_onroad_full_alert_multiline(click, pm: PubMaster, scroll=None):
+def setup_onroad_full_alert_multiline(click, pm: PubMaster):
   setup_onroad_alert(click, pm, AlertSize.full, "Reverse\nGear", "", AlertStatus.normal)
 
 
-def setup_onroad_full_alert_long_text(click, pm: PubMaster, scroll=None):
+def setup_onroad_full_alert_long_text(click, pm: PubMaster):
   setup_onroad_alert(click, pm, AlertSize.full, "TAKE CONTROL IMMEDIATELY", "Calibration Invalid: Remount Device & Recalibrate", AlertStatus.userPrompt)
 
 
@@ -286,19 +243,6 @@ CASES = {
   "onroad_full_alert_long_text": setup_onroad_full_alert_long_text,
 }
 
-# sunnypilot cases
-CASES.update({
-  "settings_sunnylink": setup_settings_sunnylink,
-  "settings_models": setup_settings_models,
-  "settings_steering": setup_settings_steering,
-  "settings_cruise": setup_settings_cruise,
-  "settings_visuals": setup_settings_visuals,
-  "settings_display": setup_settings_display,
-  "settings_osm": setup_settings_osm,
-  "settings_trips": setup_settings_trips,
-  "settings_vehicle": setup_settings_vehicle,
-})
-
 
 class TestUI:
   def __init__(self):
@@ -332,15 +276,11 @@ class TestUI:
     time.sleep(0.01)
     pyautogui.mouseUp(self.ui.left + x, self.ui.top + y, *args, **kwargs)
 
-  def scroll(self, clicks, x, y, *args, **kwargs):
-    pyautogui.scroll(clicks, self.ui.left + x, self.ui.top + y, *args, **kwargs)
-    time.sleep(UI_DELAY)
-
   @with_processes(["ui"])
   def test_ui(self, name, setup_case):
     self.setup()
     time.sleep(UI_DELAY)  # wait for UI to start
-    setup_case(self.click, self.pm, self.scroll)
+    setup_case(self.click, self.pm)
     self.screenshot(name)
 
 

selfdrive/ui/ui.py

@@ -9,8 +9,6 @@ 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/navd/README.md

@@ -0,0 +1,5 @@
+# Navigation
+
+Navigation daemon with Mapbox integration for semi-offline navigation. This module handles route planning, geocoding, and turn-by-turn instructions to support autonomous driving features.
+
+- `navigation_helpers/`: Mapbox API integration and navigation instructions processing.

sunnypilot/navd/helpers.py

@@ -72,6 +72,15 @@ class Coordinate:
     return x * EARTH_MEAN_RADIUS
 
 
+def bearing_between_two_points(point_one: Coordinate, point_two: Coordinate) -> float:
+  dlon = math.radians(point_two.longitude - point_one.longitude)
+  bearing_radians = math.atan2(math.sin(dlon)* math.cos(point_two.latitude), math.cos(point_one.latitude) * math.sin(point_two.latitude) -
+                               math.sin(point_one.latitude) * math.cos(point_two.latitude) * math.cos(dlon))
+  bearing_degrees = math.degrees(bearing_radians)
+  bearing_normalized = (bearing_degrees + 360) % 360
+  return bearing_normalized
+
+
 def minimum_distance(a: Coordinate, b: Coordinate, p: Coordinate):
   if a.distance_to(b) < 0.01:
     return a.distance_to(p)
@@ -126,6 +135,8 @@ def string_to_direction(direction: str) -> str:
     if d in direction:
       if 'slight' in direction and d in MODIFIABLE_DIRECTIONS:
         return 'slight' + d.capitalize()
+      elif 'sharp' in direction and d in MODIFIABLE_DIRECTIONS:
+        return 'sharp' + d.capitalize()
       return d
   return 'none'
 

sunnypilot/navd/navigation_helpers/mapbox_integration.py

@@ -0,0 +1,113 @@
+"""
+Copyright (c) 2021-, James Vecellio, 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 requests
+from urllib.parse import quote
+
+from openpilot.common.params import Params
+
+
+class MapboxIntegration:
+  def __init__(self):
+    self.params = Params()
+
+  def get_public_token(self) -> str:
+    token: str = self.params.get('MapboxToken', return_default=True)
+    return token
+
+  def set_destination(self, postvars, current_lon, current_lat, bearing=None) -> tuple[dict, bool]:
+    if 'latitude' in postvars and 'longitude' in postvars:
+      self.nav_confirmed(postvars, current_lon, current_lat, bearing)
+      return postvars, True
+
+    addr = postvars['place_name']
+    if not addr:
+      return postvars, False
+
+    token = self.get_public_token()
+    url = f'https://api.mapbox.com/geocoding/v5/mapbox.places/{quote(addr)}.json?access_token={token}&limit=1&proximity={current_lon},{current_lat}'
+    try:
+      response = requests.get(url, timeout=5)
+      if response.status_code == 200:
+        features = response.json()['features']
+        if features:
+          longitude, latitude = features[0]['geometry']['coordinates']
+          postvars.update({'latitude': latitude, 'longitude': longitude, 'name': addr})
+          self.nav_confirmed(postvars, current_lon, current_lat, bearing)
+          return postvars, True
+    except requests.RequestException:
+      pass  # Broad exception to handle network errors like no internet without crashing navd process.
+    return postvars, False
+
+  def nav_confirmed(self, postvars, start_lon, start_lat, bearing=None) -> None:
+    if not postvars:
+      return
+
+    latitude = float(postvars['latitude'])
+    longitude = float(postvars['longitude'])
+
+    data: dict = {'navData': {'current': {'latitude': latitude, 'longitude': longitude}, 'route': {}}}
+
+    token = self.get_public_token()
+    route_data = self.generate_route(start_lon, start_lat, longitude, latitude, token, bearing)
+    if route_data:
+      data['navData']['route'] = route_data
+    self.params.put('MapboxSettings', data)
+
+  @staticmethod
+  def generate_route(start_lon, start_lat, end_lon, end_lat, token, bearing=None) -> dict | None:
+    if not token:
+      return None
+
+    params = {
+      'access_token': token,
+      'geometries': 'geojson',
+      'steps': 'true',
+      'overview': 'full',
+      'annotations': 'maxspeed',
+      'alternatives': 'false',
+      'banner_instructions': 'true',
+    }
+    if bearing is not None:
+      params['bearings'] = f'{int((bearing + 360) % 360):.0f},90;'
+
+    try:
+      response = requests.get(f'https://api.mapbox.com/directions/v5/mapbox/driving/{start_lon},{start_lat};{end_lon},{end_lat}', params=params, timeout=5)
+      data = response.json() if response.status_code == 200 else {}
+    except requests.RequestException:
+      return None
+
+    routes = data['routes'] if data else None
+    legs = routes[0]['legs'] if routes else None
+
+    if data.get('code') != 'Ok' or not routes or not legs:
+      return None
+
+    route = routes[0]
+    leg = legs[0]
+
+    steps = [
+      {
+        'maneuver': step['maneuver']['type'],
+        'instruction': step['maneuver']['instruction'],
+        'distance': step['distance'],
+        'duration': step['duration'],
+        'location': {'longitude': step['maneuver']['location'][0], 'latitude': step['maneuver']['location'][1]},
+        'modifier': step['maneuver'].get('modifier', 'none'),
+        'bannerInstructions': step['bannerInstructions'],
+      }
+      for step in leg['steps']
+    ]
+
+    maxspeed = [{'speed': item['speed'], 'unit': item['unit']} for item in leg['annotation']['maxspeed'] if 'speed' in item]
+
+    return {
+      'steps': steps,
+      'totalDistance': route['distance'],
+      'totalDuration': route['duration'],
+      'geometry': [{'longitude': coord[0], 'latitude': coord[1]} for coord in route['geometry']['coordinates']],
+      'maxspeed': maxspeed,
+    }

sunnypilot/navd/navigation_helpers/nav_instructions.py

@@ -0,0 +1,152 @@
+"""
+Copyright (c) 2021-, James Vecellio, 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 numpy import interp
+
+from openpilot.common.params import Params
+
+from openpilot.sunnypilot.navd.helpers import Coordinate, bearing_between_two_points, distance_along_geometry, string_to_direction
+
+
+class NavigationInstructions:
+  def __init__(self):
+    self.coord = Coordinate(0, 0)
+    self.params = Params()
+
+    self._cached_route = None
+    self._route_loaded = False
+    self._no_route = False
+
+    self.closest_idx: float = 0
+
+  def get_route_progress(self, current_lat, current_lon) -> dict | None:
+    route = self.get_current_route()
+    if not route or not route['geometry'] or not route['steps']:
+      return None
+
+    self.coord.latitude = current_lat
+    self.coord.longitude = current_lon
+
+    # Find the closest point on the route relative to self
+    self.closest_idx, min_distance = min(((idx, self.coord.distance_to(coord)) for idx, coord in enumerate(route['geometry'])), key=lambda x: x[1])
+    closest_cumulative = distance_along_geometry(route['geometry'], self.coord)
+
+    # Find the current step index, which is the HIGHEST idx where the step location cumulative less/equal closest cumulative
+    current_step_idx = max((idx for idx, step in enumerate(route['steps']) if step['cumulative_distance'] <= closest_cumulative), default=-1)
+    current_step = route['steps'][current_step_idx if current_step_idx >= 0 else 0]
+
+    # The next turn is the next step relative to our cumulative index
+    next_turn_idx = current_step_idx + 1
+    next_turn = route['steps'][next_turn_idx] if 0 <= next_turn_idx < len(route['steps']) else None
+
+    current_maxspeed = current_step['maxspeed']
+
+    distance_to_end_of_step = max(0, current_step['distance'] - (closest_cumulative - current_step['cumulative_distance']))
+
+    all_maneuvers: list = []
+    max_maneuvers = 3
+    for idx in range(current_step_idx, min(current_step_idx + max_maneuvers, len(route['steps']))):
+      step = route['steps'][idx]
+      if idx == current_step_idx:
+        distance = distance_to_end_of_step
+      else:
+        distance = step['cumulative_distance'] - closest_cumulative
+      all_maneuvers.append({'distance': distance, 'type': step['maneuver'], 'modifier': step['modifier'], 'instruction': step['instruction']})
+
+    return {
+      'distance_from_route': min_distance,
+      'current_step': current_step,
+      'next_turn': next_turn,
+      'current_maxspeed': current_maxspeed,
+      'all_maneuvers': all_maneuvers,
+      'current_step_idx': current_step_idx,
+      'distance_to_end_of_step': distance_to_end_of_step,
+    }
+
+  def get_current_route(self):
+    if self._route_loaded and self._cached_route is not None:
+      return self._cached_route
+    if self._no_route:
+      return None
+
+    param_value = self.params.get('MapboxSettings')
+    route = param_value['navData']['route'] if param_value else None
+    if not route:
+      self._no_route = True
+      return None
+
+    geometry = [Coordinate(coord['latitude'], coord['longitude']) for coord in route['geometry']]
+    cumulative_distances = [0.0]
+    cumulative_distances.extend(cumulative_distances[-1] + geometry[step - 1].distance_to(geometry[step]) for step in range(1, len(geometry)))
+    maxspeed = [(speed['speed'], speed['unit']) for speed in route['maxspeed']]
+    steps = []
+    for step in route['steps']:
+      location = Coordinate(step['location']['latitude'], step['location']['longitude'])
+      closest_idx = min(range(len(geometry)), key=lambda i: location.distance_to(geometry[i]))
+      steps.append({
+        'bannerInstructions': step['bannerInstructions'],
+        'distance': step['distance'],
+        'duration': step['duration'],
+        'maneuver': step['maneuver'],
+        'location': location,
+        'cumulative_distance': cumulative_distances[closest_idx],
+        'maxspeed': maxspeed[min(closest_idx, len(maxspeed) - 1)] if len(maxspeed) > 0 else (0, 'kmh'),
+        'modifier': string_to_direction(step['modifier']),
+        'instruction': step['instruction'],
+      })
+    self._cached_route = {
+      'bearings': [bearing_between_two_points(geometry[i], geometry[i+2]) for i in range(len(geometry)-2)],
+      'steps': steps,
+      'total_distance': route['totalDistance'],
+      'total_duration': route['totalDuration'],
+      'geometry': geometry,
+      'cumulative_distances': cumulative_distances,
+      'maxspeed': maxspeed,
+    }
+    self._route_loaded = True
+    return self._cached_route
+
+  def clear_route_cache(self):
+    self._cached_route = None
+    self._route_loaded = False
+    self._no_route = False
+
+  def route_bearing_misalign(self, route, bearing, v_ego) -> bool:
+    route_bearing_misalign:bool = False
+
+    if v_ego < 5.0:
+      route_bearing_misalign = False
+    elif 0 < self.closest_idx < len(route['geometry']) -1:
+      route_bearing = route['bearings'][self.closest_idx -1]
+      current_bearing_normalized = (bearing + 360) % 360
+      bearing_difference = abs(current_bearing_normalized - route_bearing)
+
+      if min(bearing_difference, 360 - bearing_difference) > 95:
+        route_bearing_misalign = True  # flag for recompute/cancellation
+    return route_bearing_misalign
+
+  def get_upcoming_turn_from_progress(self, progress, current_lat, current_lon, v_ego: float) -> str:
+    if progress and progress['next_turn']:
+      speed_breakpoints: list = [0, 5, 10, 15, 20, 25, 30, 35, 40]
+      distance_breakpoints: list = [20, 25, 30, 45, 60, 75, 90, 105, 120]
+      distance_interp = interp(v_ego, speed_breakpoints, distance_breakpoints)
+
+      self.coord.latitude = current_lat
+      self.coord.longitude = current_lon
+      distance = self.coord.distance_to(progress['next_turn']['location'])
+
+      if distance <= distance_interp:
+        modifier = progress['next_turn']['modifier']
+        return str(modifier)
+    return 'none'
+
+  @staticmethod
+  def arrived_at_destination(progress, v_ego) -> bool:
+    if v_ego < 1.0:
+      maneuvers = progress['all_maneuvers'][0]
+      if maneuvers['type'] == 'arrive' or maneuvers['instruction'].startswith('Your destination'):
+        return True
+    return False

sunnypilot/navd/navigation_helpers/tests/test_mapbox.py

@@ -0,0 +1,98 @@
+"""
+Copyright (c) 2021-, James Vecellio, 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 os
+
+from openpilot.common.constants import CV
+
+from openpilot.sunnypilot.navd.navigation_helpers.mapbox_integration import MapboxIntegration
+from openpilot.sunnypilot.navd.navigation_helpers.nav_instructions import NavigationInstructions
+
+
+class TestMapbox:
+  @classmethod
+  def setup_class(cls):
+    cls.mapbox = MapboxIntegration()
+    cls.nav = NavigationInstructions()
+
+    token = os.environ.get('MAPBOX_TOKEN_CI')
+    if token:
+      cls.mapbox.params.put('MapboxToken', token)
+
+    # route setup
+    cls.current_lon, cls.current_lat = -119.17557, 34.23305
+    cls.mapbox.params.put('MapboxRoute', '740 E Ventura Blvd. Camarillo, CA')
+    cls.postvars = {"place_name": cls.mapbox.params.get('MapboxRoute')}
+    cls.postvars, cls.valid_addr = cls.mapbox.set_destination(cls.postvars, cls.current_lon, cls.current_lat)
+    cls.route = cls.nav.get_current_route()
+    cls.progress = cls.nav.get_route_progress(cls.current_lat, cls.current_lon)
+
+  def test_set_destination(self):
+    assert self.valid_addr
+    settings = self.mapbox.params.get('MapboxSettings')
+    assert settings is not None
+    dest_lat = settings['navData']['current']['latitude']
+    dest_lon = settings['navData']['current']['longitude']
+    assert dest_lat == self.postvars["latitude"] and dest_lon == self.postvars["longitude"]
+
+  def test_get_route(self):
+    assert self.route is not None
+    assert 'steps' in self.route
+    assert 'geometry' in self.route
+    assert 'maxspeed' in self.route
+    assert 'total_distance' in self.route
+    assert 'total_duration' in self.route
+    assert len(self.route['steps']) > 0
+    assert len(self.route['geometry']) > 0
+    assert len(self.route['maxspeed']) > 0
+
+    if self.route and 'steps' in self.route:
+      for step in self.route['steps']:
+        assert 'modifier' in step
+
+  def test_upcoming_turn_detection(self):
+    upcoming = self.nav.get_upcoming_turn_from_progress(self.progress, self.current_lat, self.current_lon, v_ego=40.0)
+    assert isinstance(upcoming, str)
+    assert upcoming == 'none'
+
+    if self.route['steps']:
+      turn_lat = self.route['steps'][1]['location'].latitude
+      turn_lon = self.route['steps'][1]['location'].longitude
+      close_lat = turn_lat - 0.000175  # slightly before the turn
+      if self.progress and self.progress.get('next_turn'):
+        expected_turn = self.progress['next_turn']['modifier']
+        upcoming_close = self.nav.get_upcoming_turn_from_progress(self.progress, close_lat, turn_lon, v_ego=0.0)
+        if expected_turn:
+          assert upcoming_close == expected_turn == 'right', "Should be a right turn upcoming"
+
+  def test_route_progress_tracking(self):
+    assert self.progress is not None
+    assert 'distance_from_route' in self.progress
+    assert 'next_turn' in self.progress
+    assert 'current_maxspeed' in self.progress
+    assert 'all_maneuvers' in self.progress
+    assert 'distance_to_end_of_step' in self.progress
+    assert self.progress['distance_from_route'] >= 0
+    assert isinstance(self.progress['all_maneuvers'], list)
+
+  def test_speed_limit_handling(self):
+    speed_limit_metric = self.progress['current_maxspeed'][0]
+    speed_limit_imperial = (round(speed_limit_metric * CV.KPH_TO_MPH))
+    assert isinstance(speed_limit_metric, int)
+    assert isinstance(speed_limit_imperial, int)
+
+  def test_arrival_detection(self):
+    is_arrived = self.nav.arrived_at_destination(self.progress, 2.0)
+    assert isinstance(is_arrived, bool)
+    assert not is_arrived
+
+  def test_bearing_misalign(self):
+    lat = self.route['steps'][1]['location'].latitude
+    lon = self.route['steps'][1]['location'].longitude
+    self.nav.get_route_progress(lat, lon)
+    route_bearing_misaligned = self.nav.route_bearing_misalign(self.route, 45, 5.0)
+    # based on math: closest index: 7, normalized bearing: 45 route bearing: 180.5486953778888, expected differential: 135.54869538
+    assert route_bearing_misaligned

sunnypilot/selfdrive/assets/offroad/icon_firehose.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a258a022f0ab90368327d899ed4fb85b47dd0e35c93508e35851d9c3184528c0
-size 36382

sunnypilot/selfdrive/assets/offroad/icon_home.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8623dbc5c7dd043a91d98777cb423cfd116014ed6390af6d7d00c1f8dea3c6e8
-size 1181

sunnypilot/sunnylink/sunnylink_state.py

@@ -1,195 +0,0 @@
-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/sunnypilot/widgets/sunnylink_pairing_dialog.py

@@ -1,130 +0,0 @@
-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/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), int(self._rect.y),
-                 int(self._rect.x + self._rect.width), int(self._rect.y),
+    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),
                  LINE_COLOR)