Merge branch 'upstream/openpilot/master' into sync-20250823

# Conflicts:
#	.github/workflows/release.yaml
#	README.md
#	RELEASES.md
#	common/params_keys.h
#	docs/CARS.md
#	opendbc_repo
#	panda
#	release/build_stripped.sh
#	selfdrive/controls/lib/longitudinal_planner.py
#	selfdrive/modeld/modeld.py
#	selfdrive/ui/feedback/feedbackd.py
#	selfdrive/ui/translations/main_ar.ts
#	selfdrive/ui/translations/main_de.ts
#	selfdrive/ui/translations/main_es.ts
#	selfdrive/ui/translations/main_fr.ts
#	selfdrive/ui/translations/main_ja.ts
#	selfdrive/ui/translations/main_ko.ts
#	selfdrive/ui/translations/main_pt-BR.ts
#	selfdrive/ui/translations/main_th.ts
#	selfdrive/ui/translations/main_tr.ts
#	selfdrive/ui/translations/main_zh-CHS.ts
#	selfdrive/ui/translations/main_zh-CHT.ts
#	system/version.py
#	uv.lock

system/ui/lib/application.py

@@ -67,7 +67,8 @@ class MouseEvent(NamedTuple):
 
 
 class MouseState:
-  def __init__(self):
+  def __init__(self, scale: float = 1.0):
+    self._scale = scale
     self._events: deque[MouseEvent] = deque(maxlen=MOUSE_THREAD_RATE)  # bound event list
     self._prev_mouse_event: list[MouseEvent | None] = [None] * MAX_TOUCH_SLOTS
 
@@ -102,8 +103,10 @@ class MouseState:
   def _handle_mouse_event(self):
     for slot in range(MAX_TOUCH_SLOTS):
       mouse_pos = rl.get_touch_position(slot)
+      x = mouse_pos.x / self._scale if self._scale != 1.0 else mouse_pos.x
+      y = mouse_pos.y / self._scale if self._scale != 1.0 else mouse_pos.y
       ev = MouseEvent(
-        MousePos(mouse_pos.x, mouse_pos.y),
+        MousePos(x, y),
         slot,
         rl.is_mouse_button_pressed(slot),
         rl.is_mouse_button_released(slot),
@@ -133,7 +136,7 @@ class GuiApplication:
     self._trace_log_callback = None
     self._modal_overlay = ModalOverlay()
 
-    self._mouse = MouseState()
+    self._mouse = MouseState(self._scale)
     self._mouse_events: list[MouseEvent] = []
 
     # Debug variables

system/ui/lib/shader_polygon.py

@@ -39,6 +39,10 @@ vec4 getGradientColor(vec2 pos) {
   float t = clamp(dot(pos - gradientStart, normalizedDir) / gradientLength, 0.0, 1.0);
 
   if (gradientColorCount <= 1) return gradientColors[0];
+
+  // handle t before first / after last stop
+  if (t <= gradientStops[0]) return gradientColors[0];
+  if (t >= gradientStops[gradientColorCount-1]) return gradientColors[gradientColorCount-1];
   for (int i = 0; i < gradientColorCount - 1; i++) {
     if (t >= gradientStops[i] && t <= gradientStops[i+1]) {
       float segmentT = (t - gradientStops[i]) / (gradientStops[i+1] - gradientStops[i]);

system/ui/lib/wifi_manager.py

@@ -37,7 +37,7 @@ NM_DEVICE_IFACE = "org.freedesktop.NetworkManager.Device"
 NM_DEVICE_STATE_REASON_SUPPLICANT_DISCONNECT = 8
 
 TETHERING_IP_ADDRESS = "192.168.43.1"
-DEFAULT_TETHERING_PASSWORD = "12345678"
+DEFAULT_TETHERING_PASSWORD = "swagswagcomma"
 
 
 # NetworkManager device states

system/ui/setup.py

@@ -6,10 +6,14 @@ import time
 import urllib.request
 from urllib.parse import urlparse
 from enum import IntEnum
+import shutil
+
 import pyray as rl
 
 from cereal import log
+from openpilot.common.run import run_cmd
 from openpilot.system.hardware import HARDWARE
+from openpilot.system.ui.lib.scroll_panel import GuiScrollPanel
 from openpilot.system.ui.lib.application import gui_app, FontWeight
 from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.button import Button, ButtonStyle, ButtonRadio
@@ -30,6 +34,19 @@ BUTTON_SPACING = 50
 OPENPILOT_URL = "https://openpilot.comma.ai"
 USER_AGENT = f"AGNOSSetup-{HARDWARE.get_os_version()}"
 
+CONTINUE_PATH = "/data/continue.sh"
+TMP_CONTINUE_PATH = "/data/continue.sh.new"
+INSTALL_PATH = "/data/openpilot"
+VALID_CACHE_PATH = "/data/.openpilot_cache"
+INSTALLER_SOURCE_PATH = "/usr/comma/installer"
+INSTALLER_DESTINATION_PATH = "/tmp/installer"
+INSTALLER_URL_PATH = "/tmp/installer_url"
+
+CONTINUE = """#!/usr/bin/env bash
+
+cd /data/openpilot
+exec ./launch_openpilot.sh
+"""
 
 class SetupState(IntEnum):
   LOW_VOLTAGE = 0
@@ -93,14 +110,21 @@ class Setup(Widget):
     self._network_setup_continue_button.set_enabled(False)
     self._network_setup_title_label = Label("Connect to Wi-Fi", TITLE_FONT_SIZE, FontWeight.BOLD, TextAlignment.LEFT)
 
-    self._custom_software_warning_continue_button = Button("Continue", self._custom_software_warning_continue_button_callback)
+    self._custom_software_warning_continue_button = Button("Scroll to continue", self._custom_software_warning_continue_button_callback,
+                                                           button_style=ButtonStyle.PRIMARY)
+    self._custom_software_warning_continue_button.set_enabled(False)
     self._custom_software_warning_back_button = Button("Back", self._custom_software_warning_back_button_callback)
     self._custom_software_warning_title_label = Label("WARNING: Custom Software", 100, FontWeight.BOLD, TextAlignment.LEFT, text_color=rl.Color(255,89,79,255),
                                                       text_padding=60)
-    self._custom_software_warning_body_label = Label("Use caution when installing third-party software. Third-party software has not been tested by comma,"
-                                              + " and may cause damage to your device and/or vehicle.\n\nIf you'd like to proceed, use https://flash.comma.ai "
+    self._custom_software_warning_body_label = Label("Use caution when installing third-party software.\n\n"
+                                              + "⚠️ It has not been tested by comma.\n\n"
+                                              + "⚠️ It may not comply with relevant safety standards.\n\n"
+                                              + "⚠️ It may cause damage to your device and/or vehicle.\n\n"
+                                              + "If you'd like to proceed, use https://flash.comma.ai "
                                               + "to restore your device to a factory state later.",
                                              85, text_alignment=TextAlignment.LEFT, text_padding=60)
+    self._custom_software_warning_body_scroll_panel = GuiScrollPanel()
+
     self._downloading_body_label = Label("Downloading...", TITLE_FONT_SIZE, FontWeight.MEDIUM)
 
     try:
@@ -136,21 +160,19 @@ class Setup(Widget):
     self.state = SetupState.SOFTWARE_SELECTION
 
   def _custom_software_warning_continue_button_callback(self):
-    self.state = SetupState.CUSTOM_SOFTWARE
+    self.state = SetupState.NETWORK_SETUP
+    self.stop_network_check_thread.clear()
+    self.start_network_check()
 
   def _getting_started_button_callback(self):
-    self.state = SetupState.NETWORK_SETUP
-    self.stop_network_check_thread.clear()
-    self.start_network_check()
+    self.state = SetupState.SOFTWARE_SELECTION
 
   def _software_selection_back_button_callback(self):
-    self.state = SetupState.NETWORK_SETUP
-    self.stop_network_check_thread.clear()
-    self.start_network_check()
+    self.state = SetupState.GETTING_STARTED
 
   def _software_selection_continue_button_callback(self):
     if self._software_selection_openpilot_button.selected:
-      self.download(OPENPILOT_URL)
+      self.use_openpilot()
     else:
       self.state = SetupState.CUSTOM_SOFTWARE_WARNING
 
@@ -158,11 +180,14 @@ class Setup(Widget):
     self.state = SetupState.GETTING_STARTED
 
   def _network_setup_back_button_callback(self):
-    self.state = SetupState.GETTING_STARTED
+    self.state = SetupState.SOFTWARE_SELECTION
 
   def _network_setup_continue_button_callback(self):
-    self.state = SetupState.SOFTWARE_SELECTION
     self.stop_network_check_thread.set()
+    if self._software_selection_openpilot_button.selected:
+      self.download(OPENPILOT_URL)
+    else:
+      self.state = SetupState.CUSTOM_SOFTWARE
 
   def render_low_voltage(self, rect: rl.Rectangle):
     rl.draw_texture(self.warning, int(rect.x + 150), int(rect.y + 110), rl.WHITE)
@@ -274,13 +299,23 @@ class Setup(Widget):
     self._download_failed_startover_button.render(rl.Rectangle(rect.x + MARGIN + button_width + BUTTON_SPACING, button_y, button_width, BUTTON_HEIGHT))
 
   def render_custom_software_warning(self, rect: rl.Rectangle):
-    self._custom_software_warning_title_label.render(rl.Rectangle(rect.x + 50, rect.y + 150, rect.width - 265, TITLE_FONT_SIZE))
-    self._custom_software_warning_body_label.render(rl.Rectangle(rect.x + 50, rect.y + 200 , rect.width - 50, BODY_FONT_SIZE * 3))
+    warn_rect = rl.Rectangle(rect.x, rect.y, rect.width, 1500)
+    offset = self._custom_software_warning_body_scroll_panel.handle_scroll(rect, warn_rect)
 
     button_width = (rect.width - MARGIN * 3) / 2
     button_y = rect.height - MARGIN - BUTTON_HEIGHT
+
+    rl.begin_scissor_mode(int(rect.x), int(rect.y), int(rect.width), int(button_y - BODY_FONT_SIZE))
+    y_offset = rect.y + offset.y
+    self._custom_software_warning_title_label.render(rl.Rectangle(rect.x + 50, y_offset + 150, rect.width - 265, TITLE_FONT_SIZE))
+    self._custom_software_warning_body_label.render(rl.Rectangle(rect.x + 50, y_offset + 200 , rect.width - 50, BODY_FONT_SIZE * 3))
+    rl.end_scissor_mode()
+
     self._custom_software_warning_back_button.render(rl.Rectangle(rect.x + MARGIN, button_y, button_width, BUTTON_HEIGHT))
     self._custom_software_warning_continue_button.render(rl.Rectangle(rect.x + MARGIN * 2 + button_width, button_y, button_width, BUTTON_HEIGHT))
+    if offset.y < (rect.height - warn_rect.height):
+      self._custom_software_warning_continue_button.set_enabled(True)
+      self._custom_software_warning_continue_button.set_text("Continue")
 
   def render_custom_software(self):
     def handle_keyboard_result(result):
@@ -299,6 +334,23 @@ class Setup(Widget):
     self.keyboard.set_title("Enter URL", "for Custom Software")
     gui_app.set_modal_overlay(self.keyboard, callback=handle_keyboard_result)
 
+  def use_openpilot(self):
+    if os.path.isdir(INSTALL_PATH) and os.path.isfile(VALID_CACHE_PATH):
+      os.remove(VALID_CACHE_PATH)
+      with open(TMP_CONTINUE_PATH, "w") as f:
+        f.write(CONTINUE)
+      run_cmd(["chmod", "+x", TMP_CONTINUE_PATH])
+      shutil.move(TMP_CONTINUE_PATH, CONTINUE_PATH)
+      shutil.copyfile(INSTALLER_SOURCE_PATH, INSTALLER_DESTINATION_PATH)
+
+      # give time for installer UI to take over
+      time.sleep(1)
+      gui_app.request_close()
+    else:
+      self.state = SetupState.NETWORK_SETUP
+      self.stop_network_check_thread.clear()
+      self.start_network_check()
+
   def download(self, url: str):
     # autocomplete incomplete URLs
     if re.match("^([^/.]+)/([^/]+)$", url):
@@ -316,7 +368,7 @@ class Setup(Widget):
     try:
       import tempfile
 
-      _, tmpfile = tempfile.mkstemp(prefix="installer_")
+      fd, tmpfile = tempfile.mkstemp(prefix="installer_")
 
       headers = {"User-Agent": USER_AGENT, "X-openpilot-serial": HARDWARE.get_serial()}
       req = urllib.request.Request(self.download_url, headers=headers)
@@ -346,12 +398,16 @@ class Setup(Widget):
         self.download_failed(self.download_url, "No custom software found at this URL.")
         return
 
-      os.rename(tmpfile, "/tmp/installer")
-      os.chmod("/tmp/installer", 0o755)
+      # AGNOS might try to execute the installer before this process exits.
+      # Therefore, important to close the fd before renaming the installer.
+      os.close(fd)
+      os.rename(tmpfile, INSTALLER_DESTINATION_PATH)
 
-      with open("/tmp/installer_url", "w") as f:
+      with open(INSTALLER_URL_PATH, "w") as f:
         f.write(self.download_url)
 
+      # give time for installer UI to take over
+      time.sleep(5)
       gui_app.request_close()
 
     except Exception:

system/ui/widgets/network.py

@@ -1,17 +1,17 @@
-from dataclasses import dataclass
+from enum import IntEnum
 from functools import partial
 from threading import Lock
-from typing import Literal
+from typing import cast
 
 import pyray as rl
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.lib.scroll_panel import GuiScrollPanel
 from openpilot.system.ui.lib.wifi_manager import NetworkInfo, WifiManagerCallbacks, WifiManagerWrapper, SecurityType
 from openpilot.system.ui.widgets import Widget
-from openpilot.system.ui.widgets.button import ButtonStyle, Button, TextAlignment
+from openpilot.system.ui.widgets.button import ButtonStyle, Button
 from openpilot.system.ui.widgets.confirm_dialog import ConfirmDialog
 from openpilot.system.ui.widgets.keyboard import Keyboard
-from openpilot.system.ui.widgets.label import gui_label
+from openpilot.system.ui.widgets.label import TextAlignment, gui_label
 
 NM_DEVICE_STATE_NEED_AUTH = 60
 MIN_PASSWORD_LENGTH = 8
@@ -27,43 +27,20 @@ STRENGTH_ICONS = [
 ]
 
 
-@dataclass
-class StateIdle:
-  action: Literal["idle"] = "idle"
-
-
-@dataclass
-class StateConnecting:
-  network: NetworkInfo
-  action: Literal["connecting"] = "connecting"
-
-
-@dataclass
-class StateNeedsAuth:
-  network: NetworkInfo
-  retry: bool
-  action: Literal["needs_auth"] = "needs_auth"
-
-
-@dataclass
-class StateShowForgetConfirm:
-  network: NetworkInfo
-  action: Literal["show_forget_confirm"] = "show_forget_confirm"
-
-
-@dataclass
-class StateForgetting:
-  network: NetworkInfo
-  action: Literal["forgetting"] = "forgetting"
-
-
-UIState = StateIdle | StateConnecting | StateNeedsAuth | StateShowForgetConfirm | StateForgetting
+class UIState(IntEnum):
+  IDLE = 0
+  CONNECTING = 1
+  NEEDS_AUTH = 2
+  SHOW_FORGET_CONFIRM = 3
+  FORGETTING = 4
 
 
 class WifiManagerUI(Widget):
   def __init__(self, wifi_manager: WifiManagerWrapper):
     super().__init__()
-    self.state: UIState = StateIdle()
+    self.state: UIState = UIState.IDLE
+    self._state_network: NetworkInfo | None = None  # for CONNECTING / NEEDS_AUTH / SHOW_FORGET_CONFIRM / FORGETTING
+    self._password_retry: bool = False  # for NEEDS_AUTH
     self.btn_width: int = 200
     self.scroll_panel = GuiScrollPanel()
     self.keyboard = Keyboard(max_text_size=MAX_PASSWORD_LENGTH, min_text_size=MIN_PASSWORD_LENGTH, show_password_toggle=True)
@@ -93,17 +70,16 @@ class WifiManagerUI(Widget):
         gui_label(rect, "Scanning Wi-Fi networks...", 72, alignment=rl.GuiTextAlignment.TEXT_ALIGN_CENTER)
         return
 
-      match self.state:
-        case StateNeedsAuth(network, retry):
-          self.keyboard.set_title("Wrong password" if retry else "Enter password", f"for {network.ssid}")
-          self.keyboard.reset()
-          gui_app.set_modal_overlay(self.keyboard, lambda result: self._on_password_entered(network, result))
-        case StateShowForgetConfirm(network):
-          self._confirm_dialog.set_text(f'Forget Wi-Fi Network "{network.ssid}"?')
-          self._confirm_dialog.reset()
-          gui_app.set_modal_overlay(self._confirm_dialog, callback=lambda result: self.on_forgot_confirm_finished(network, result))
-        case _:
-          self._draw_network_list(rect)
+      if self.state == UIState.NEEDS_AUTH and self._state_network:
+        self.keyboard.set_title("Wrong password" if self._password_retry else "Enter password", f"for {self._state_network.ssid}")
+        self.keyboard.reset()
+        gui_app.set_modal_overlay(self.keyboard, lambda result: self._on_password_entered(cast(NetworkInfo, self._state_network), result))
+      elif self.state == UIState.SHOW_FORGET_CONFIRM and self._state_network:
+        self._confirm_dialog.set_text(f'Forget Wi-Fi Network "{self._state_network.ssid}"?')
+        self._confirm_dialog.reset()
+        gui_app.set_modal_overlay(self._confirm_dialog, callback=lambda result: self.on_forgot_confirm_finished(self._state_network, result))
+      else:
+        self._draw_network_list(rect)
 
   def _on_password_entered(self, network: NetworkInfo, result: int):
     if result == 1:
@@ -113,13 +89,13 @@ class WifiManagerUI(Widget):
       if len(password) >= MIN_PASSWORD_LENGTH:
         self.connect_to_network(network, password)
     elif result == 0:
-      self.state = StateIdle()
+      self.state = UIState.IDLE
 
   def on_forgot_confirm_finished(self, network, result: int):
     if result == 1:
       self.forget_network(network)
     elif result == 0:
-      self.state = StateIdle()
+      self.state = UIState.IDLE
 
   def _draw_network_list(self, rect: rl.Rectangle):
     content_rect = rl.Rectangle(rect.x, rect.y, rect.width, len(self._networks) * ITEM_HEIGHT)
@@ -147,17 +123,18 @@ class WifiManagerUI(Widget):
     security_icon_rect = rl.Rectangle(signal_icon_rect.x - spacing - ICON_SIZE, rect.y + (ITEM_HEIGHT - ICON_SIZE) / 2, ICON_SIZE, ICON_SIZE)
 
     status_text = ""
-    match self.state:
-      case StateConnecting(network=connecting):
-        if connecting.ssid == network.ssid:
-          self._networks_buttons[network.ssid].set_enabled(False)
-          status_text = "CONNECTING..."
-      case StateForgetting(network=forgetting):
-        if forgetting.ssid == network.ssid:
-          self._networks_buttons[network.ssid].set_enabled(False)
-          status_text = "FORGETTING..."
-      case _:
-        self._networks_buttons[network.ssid].set_enabled(True)
+    if self.state == UIState.CONNECTING and self._state_network:
+      if self._state_network.ssid == network.ssid:
+        self._networks_buttons[network.ssid].set_enabled(False)
+        status_text = "CONNECTING..."
+    elif self.state == UIState.FORGETTING and self._state_network:
+      if self._state_network.ssid == network.ssid:
+        self._networks_buttons[network.ssid].set_enabled(False)
+        status_text = "FORGETTING..."
+    elif network.security_type == SecurityType.UNSUPPORTED:
+      self._networks_buttons[network.ssid].set_enabled(False)
+    else:
+      self._networks_buttons[network.ssid].set_enabled(True)
 
     self._networks_buttons[network.ssid].render(ssid_rect)
 
@@ -181,13 +158,16 @@ class WifiManagerUI(Widget):
   def _networks_buttons_callback(self, network):
     if self.scroll_panel.is_touch_valid():
       if not network.is_saved and network.security_type != SecurityType.OPEN:
-        self.state = StateNeedsAuth(network, False)
+        self.state = UIState.NEEDS_AUTH
+        self._state_network = network
+        self._password_retry = False
       elif not network.is_connected:
         self.connect_to_network(network)
 
   def _forget_networks_buttons_callback(self, network):
     if self.scroll_panel.is_touch_valid():
-      self.state = StateShowForgetConfirm(network)
+      self.state = UIState.SHOW_FORGET_CONFIRM
+      self._state_network = network
 
   def _draw_status_icon(self, rect, network: NetworkInfo):
     """Draw the status icon based on network's connection state"""
@@ -212,14 +192,16 @@ class WifiManagerUI(Widget):
     rl.draw_texture_v(gui_app.texture(STRENGTH_ICONS[strength_level], ICON_SIZE, ICON_SIZE), rl.Vector2(rect.x, rect.y), rl.WHITE)
 
   def connect_to_network(self, network: NetworkInfo, password=''):
-    self.state = StateConnecting(network)
+    self.state = UIState.CONNECTING
+    self._state_network = network
     if network.is_saved and not password:
       self.wifi_manager.activate_connection(network.ssid)
     else:
       self.wifi_manager.connect_to_network(network.ssid, password)
 
   def forget_network(self, network: NetworkInfo):
-    self.state = StateForgetting(network)
+    self.state = UIState.FORGETTING
+    self._state_network = network
     network.is_saved = False
     self.wifi_manager.forget_connection(network.ssid)
 
@@ -236,22 +218,24 @@ class WifiManagerUI(Widget):
     with self._lock:
       network = next((n for n in self._networks if n.ssid == ssid), None)
       if network:
-        self.state = StateNeedsAuth(network, True)
+        self.state = UIState.NEEDS_AUTH
+        self._state_network = network
+        self._password_retry = True
 
   def _on_activated(self):
     with self._lock:
-      if isinstance(self.state, StateConnecting):
-        self.state = StateIdle()
+      if self.state == UIState.CONNECTING:
+        self.state = UIState.IDLE
 
   def _on_forgotten(self, ssid):
     with self._lock:
-      if isinstance(self.state, StateForgetting):
-        self.state = StateIdle()
+      if self.state == UIState.FORGETTING:
+        self.state = UIState.IDLE
 
   def _on_connection_failed(self, ssid: str, error: str):
     with self._lock:
-      if isinstance(self.state, StateConnecting):
-        self.state = StateIdle()
+      if self.state == UIState.CONNECTING:
+        self.state = UIState.IDLE
 
 
 def main():