FrogPilot Setup

selfdrive/frogpilot/functions/frogpilot_functions.py

@@ -0,0 +1,17 @@
+import numpy as np
+
+from openpilot.common.numpy_fast import interp
+from openpilot.common.params import Params
+from openpilot.system.hardware import HARDWARE
+
+
+params_memory = Params("/dev/shm/params")
+
+CITY_SPEED_LIMIT = 25
+CRUISING_SPEED = 5  # Roughly the speed cars go when not touching the gas while in drive
+PROBABILITY = 0.6   # 60% chance of condition being true
+THRESHOLD = 5       # Time threshold (0.25s)
+
+class FrogPilotFunctions:
+  def __init__(self) -> None:
+    self.params = Params()

selfdrive/frogpilot/functions/frogpilot_planner.py

@@ -0,0 +1,49 @@
+import cereal.messaging as messaging
+
+from openpilot.common.conversions import Conversions as CV
+
+from openpilot.selfdrive.frogpilot.functions.frogpilot_functions import CRUISING_SPEED, FrogPilotFunctions
+
+class FrogPilotPlanner:
+  def __init__(self, CP, params, params_memory):
+    self.CP = CP
+    self.params_memory = params_memory
+
+    self.fpf = FrogPilotFunctions()
+
+    self.v_cruise = 0
+
+    self.update_frogpilot_params(params)
+
+  def update(self, carState, controlsState, modelData, mpc, sm, v_cruise, v_ego):
+    enabled = controlsState.enabled
+
+    # Update the max allowed speed
+    self.v_cruise = self.update_v_cruise(carState, controlsState, enabled, modelData, v_cruise, v_ego)
+
+  def update_v_cruise(self, carState, controlsState, enabled, modelData, v_cruise, v_ego):
+    # Offsets to adjust the max speed to match the cluster
+    v_ego_cluster = max(carState.vEgoCluster, v_ego)
+    v_ego_diff = v_ego_cluster - v_ego
+
+    v_cruise_cluster = max(controlsState.vCruiseCluster, controlsState.vCruise) * CV.KPH_TO_MS
+    v_cruise_diff = v_cruise_cluster - v_cruise
+
+    targets = []
+    filtered_targets = [target for target in targets if target > CRUISING_SPEED]
+
+    return min(filtered_targets) if filtered_targets else v_cruise
+
+  def publish(self, sm, pm, mpc):
+    frogpilot_plan_send = messaging.new_message('frogpilotPlan')
+    frogpilot_plan_send.valid = sm.all_checks(service_list=['carState', 'controlsState'])
+    frogpilotPlan = frogpilot_plan_send.frogpilotPlan
+
+    pm.send('frogpilotPlan', frogpilot_plan_send)
+
+  def update_frogpilot_params(self, params):
+    self.is_metric = params.get_bool("IsMetric")
+
+    custom_ui = params.get_bool("CustomUI")
+
+    longitudinal_tune = params.get_bool("LongitudinalTune")

selfdrive/frogpilot/ui/control_settings.cc

@@ -0,0 +1,163 @@
+#include "selfdrive/frogpilot/ui/control_settings.h"
+
+FrogPilotControlsPanel::FrogPilotControlsPanel(SettingsWindow *parent) : FrogPilotListWidget(parent) {
+  const std::vector<std::tuple<QString, QString, QString, QString>> controlToggles {
+    {"LateralTune", "Lateral Tuning", "Modify openpilot's steering behavior.", "../frogpilot/assets/toggle_icons/icon_lateral_tune.png"},
+
+    {"LongitudinalTune", "Longitudinal Tuning", "Modify openpilot's acceleration and braking behavior.", "../frogpilot/assets/toggle_icons/icon_longitudinal_tune.png"},
+
+    {"QOLControls", "Quality of Life", "Miscellaneous quality of life changes to improve your overall openpilot experience.", "../frogpilot/assets/toggle_icons/quality_of_life.png"},
+  };
+
+  for (const auto &[param, title, desc, icon] : controlToggles) {
+    ParamControl *toggle;
+
+    if (param == "LateralTune") {
+      FrogPilotParamManageControl *lateralTuneToggle = new FrogPilotParamManageControl(param, title, desc, icon, this);
+      QObject::connect(lateralTuneToggle, &FrogPilotParamManageControl::manageButtonClicked, this, [this]() {
+        parentToggleClicked();
+        for (auto &[key, toggle] : toggles) {
+          toggle->setVisible(lateralTuneKeys.find(key.c_str()) != lateralTuneKeys.end());
+        }
+      });
+      toggle = lateralTuneToggle;
+
+    } else if (param == "LongitudinalTune") {
+      FrogPilotParamManageControl *longitudinalTuneToggle = new FrogPilotParamManageControl(param, title, desc, icon, this);
+      QObject::connect(longitudinalTuneToggle, &FrogPilotParamManageControl::manageButtonClicked, this, [this]() {
+        parentToggleClicked();
+        for (auto &[key, toggle] : toggles) {
+          toggle->setVisible(longitudinalTuneKeys.find(key.c_str()) != longitudinalTuneKeys.end());
+        }
+      });
+      toggle = longitudinalTuneToggle;
+
+    } else if (param == "QOLControls") {
+      FrogPilotParamManageControl *qolToggle = new FrogPilotParamManageControl(param, title, desc, icon, this);
+      QObject::connect(qolToggle, &FrogPilotParamManageControl::manageButtonClicked, this, [this]() {
+        parentToggleClicked();
+        for (auto &[key, toggle] : toggles) {
+          toggle->setVisible(qolKeys.find(key.c_str()) != qolKeys.end());
+        }
+      });
+      toggle = qolToggle;
+
+    } else {
+      toggle = new ParamControl(param, title, desc, icon, this);
+    }
+
+    addItem(toggle);
+    toggles[param.toStdString()] = toggle;
+
+    QObject::connect(toggle, &ToggleControl::toggleFlipped, [this]() {
+      updateToggles();
+    });
+
+    QObject::connect(static_cast<FrogPilotButtonParamControl*>(toggle), &FrogPilotButtonParamControl::buttonClicked, [this]() {
+      updateToggles();
+    });
+
+    QObject::connect(static_cast<FrogPilotParamValueControl*>(toggle), &FrogPilotParamValueControl::valueChanged, [this]() {
+      updateToggles();
+    });
+
+    QObject::connect(toggle, &AbstractControl::showDescriptionEvent, [this]() {
+      update();
+    });
+
+    QObject::connect(static_cast<FrogPilotParamManageControl*>(toggle), &FrogPilotParamManageControl::manageButtonClicked, this, [this]() {
+      update();
+    });
+  }
+
+  std::set<std::string> rebootKeys = {};
+  for (const std::string &key : rebootKeys) {
+    QObject::connect(toggles[key], &ToggleControl::toggleFlipped, [this, key]() {
+      if (started) {
+        if (FrogPilotConfirmationDialog::toggle("Reboot required to take effect.", "Reboot Now", this)) {
+          Hardware::soft_reboot();
+        }
+      }
+    });
+  }
+
+  QObject::connect(device(), &Device::interactiveTimeout, this, &FrogPilotControlsPanel::hideSubToggles);
+  QObject::connect(parent, &SettingsWindow::closeParentToggle, this, &FrogPilotControlsPanel::hideSubToggles);
+  QObject::connect(parent, &SettingsWindow::closeSubParentToggle, this, &FrogPilotControlsPanel::hideSubSubToggles);
+  QObject::connect(parent, &SettingsWindow::updateMetric, this, &FrogPilotControlsPanel::updateMetric);
+  QObject::connect(uiState(), &UIState::offroadTransition, this, &FrogPilotControlsPanel::updateCarToggles);
+  QObject::connect(uiState(), &UIState::uiUpdate, this, &FrogPilotControlsPanel::updateState);
+
+  hideSubToggles();
+  updateMetric();
+}
+
+void FrogPilotControlsPanel::updateState(const UIState &s) {
+  started = s.scene.started;
+}
+
+void FrogPilotControlsPanel::updateToggles() {
+  std::thread([this]() {
+    paramsMemory.putBool("FrogPilotTogglesUpdated", true);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    paramsMemory.putBool("FrogPilotTogglesUpdated", false);
+  }).detach();
+}
+
+void FrogPilotControlsPanel::updateCarToggles() {
+}
+
+void FrogPilotControlsPanel::updateMetric() {
+  bool previousIsMetric = isMetric;
+  isMetric = params.getBool("IsMetric");
+
+  if (isMetric != previousIsMetric) {
+    double distanceConversion = isMetric ? FOOT_TO_METER : METER_TO_FOOT;
+    double speedConversion = isMetric ? MILE_TO_KM : KM_TO_MILE;
+  }
+
+  if (isMetric) {
+  } else {
+  }
+
+  previousIsMetric = isMetric;
+}
+
+void FrogPilotControlsPanel::parentToggleClicked() {
+  openParentToggle();
+}
+
+void FrogPilotControlsPanel::subParentToggleClicked() {
+  openSubParentToggle();
+}
+
+void FrogPilotControlsPanel::hideSubToggles() {
+  for (auto &[key, toggle] : toggles) {
+    bool subToggles = conditionalExperimentalKeys.find(key.c_str()) != conditionalExperimentalKeys.end() ||
+                      fireTheBabysitterKeys.find(key.c_str()) != fireTheBabysitterKeys.end() ||
+                      laneChangeKeys.find(key.c_str()) != laneChangeKeys.end() ||
+                      lateralTuneKeys.find(key.c_str()) != lateralTuneKeys.end() ||
+                      longitudinalTuneKeys.find(key.c_str()) != longitudinalTuneKeys.end() ||
+                      mtscKeys.find(key.c_str()) != mtscKeys.end() ||
+                      qolKeys.find(key.c_str()) != qolKeys.end() ||
+                      speedLimitControllerKeys.find(key.c_str()) != speedLimitControllerKeys.end() ||
+                      visionTurnControlKeys.find(key.c_str()) != visionTurnControlKeys.end();
+    toggle->setVisible(!subToggles);
+  }
+
+  closeParentToggle();
+}
+
+void FrogPilotControlsPanel::hideSubSubToggles() {
+  for (auto &[key, toggle] : toggles) {
+    bool isVisible = false;
+    toggle->setVisible(isVisible);
+  }
+
+  closeSubParentToggle();
+  update();
+}
+
+void FrogPilotControlsPanel::hideEvent(QHideEvent *event) {
+  hideSubToggles();
+}

selfdrive/frogpilot/ui/control_settings.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <set>
+
+#include "selfdrive/frogpilot/ui/frogpilot_ui_functions.h"
+#include "selfdrive/ui/qt/offroad/settings.h"
+#include "selfdrive/ui/ui.h"
+
+class FrogPilotControlsPanel : public FrogPilotListWidget {
+  Q_OBJECT
+
+public:
+  explicit FrogPilotControlsPanel(SettingsWindow *parent);
+
+signals:
+  void closeParentToggle();
+  void closeSubParentToggle();
+  void openParentToggle();
+  void openSubParentToggle();
+
+private:
+  void hideEvent(QHideEvent *event);
+  void hideSubSubToggles();
+  void hideSubToggles();
+  void parentToggleClicked();
+  void subParentToggleClicked();
+  void updateCarToggles();
+  void updateMetric();
+  void updateState(const UIState &s);
+  void updateToggles();
+
+  std::set<QString> conditionalExperimentalKeys = {};
+  std::set<QString> fireTheBabysitterKeys = {};
+  std::set<QString> laneChangeKeys = {};
+  std::set<QString> lateralTuneKeys = {};
+  std::set<QString> longitudinalTuneKeys = {};
+  std::set<QString> mtscKeys = {};
+  std::set<QString> qolKeys = {};
+  std::set<QString> speedLimitControllerKeys = {};
+  std::set<QString> speedLimitControllerControlsKeys = {};
+  std::set<QString> speedLimitControllerQOLKeys = {};
+  std::set<QString> speedLimitControllerVisualsKeys = {};
+  std::set<QString> visionTurnControlKeys = {};
+
+  std::map<std::string, ParamControl*> toggles;
+
+  Params params;
+  Params paramsMemory{"/dev/shm/params"};
+
+  bool isMetric = params.getBool("IsMetric");
+  bool started = false;
+};

selfdrive/frogpilot/ui/frogpilot_ui_functions.cc

@@ -0,0 +1,42 @@
+#include <filesystem>
+
+#include "selfdrive/frogpilot/ui/frogpilot_ui_functions.h"
+#include "selfdrive/ui/ui.h"
+
+bool FrogPilotConfirmationDialog::toggle(const QString &prompt_text, const QString &confirm_text, QWidget *parent) {
+  ConfirmationDialog d = ConfirmationDialog(prompt_text, confirm_text, tr("Reboot Later"), false, parent);
+  return d.exec();
+}
+
+bool FrogPilotConfirmationDialog::toggleAlert(const QString &prompt_text, const QString &button_text, QWidget *parent) {
+  ConfirmationDialog d = ConfirmationDialog(prompt_text, button_text, "", false, parent);
+  return d.exec();
+}
+
+bool FrogPilotConfirmationDialog::yesorno(const QString &prompt_text, QWidget *parent) {
+  ConfirmationDialog d = ConfirmationDialog(prompt_text, tr("Yes"), tr("No"), false, parent);
+  return d.exec();
+}
+
+FrogPilotButtonIconControl::FrogPilotButtonIconControl(const QString &title, const QString &text, const QString &desc, const QString &icon, QWidget *parent) : AbstractControl(title, desc, icon, parent) {
+  btn.setText(text);
+  btn.setStyleSheet(R"(
+    QPushButton {
+      padding: 0;
+      border-radius: 50px;
+      font-size: 35px;
+      font-weight: 500;
+      color: #E4E4E4;
+      background-color: #393939;
+    }
+    QPushButton:pressed {
+      background-color: #4a4a4a;
+    }
+    QPushButton:disabled {
+      color: #33E4E4E4;
+    }
+  )");
+  btn.setFixedSize(250, 100);
+  QObject::connect(&btn, &QPushButton::clicked, this, &FrogPilotButtonIconControl::clicked);
+  hlayout->addWidget(&btn);
+}

selfdrive/frogpilot/ui/frogpilot_ui_functions.h

@@ -0,0 +1,745 @@
+#pragma once
+
+#include <cmath>
+
+#include <QTimer>
+
+#include "selfdrive/ui/qt/widgets/controls.h"
+
+class FrogPilotConfirmationDialog : public ConfirmationDialog {
+  Q_OBJECT
+
+public:
+  explicit FrogPilotConfirmationDialog(const QString &prompt_text, const QString &confirm_text,
+                              const QString &cancel_text, const bool rich, QWidget* parent);
+  static bool toggle(const QString &prompt_text, const QString &confirm_text, QWidget *parent);
+  static bool toggleAlert(const QString &prompt_text, const QString &button_text, QWidget *parent);
+  static bool yesorno(const QString &prompt_text, QWidget *parent);
+};
+
+class FrogPilotListWidget : public QWidget {
+  Q_OBJECT
+public:
+  explicit FrogPilotListWidget(QWidget *parent = 0) : QWidget(parent), outer_layout(this) {
+    outer_layout.setMargin(0);
+    outer_layout.setSpacing(0);
+    outer_layout.addLayout(&inner_layout);
+    inner_layout.setMargin(0);
+    inner_layout.setSpacing(25); // default spacing is 25
+    outer_layout.addStretch();
+  }
+  inline void addItem(QWidget *w) { inner_layout.addWidget(w); }
+  inline void addItem(QLayout *layout) { inner_layout.addLayout(layout); }
+  inline void setSpacing(int spacing) { inner_layout.setSpacing(spacing); }
+
+private:
+  void paintEvent(QPaintEvent *) override {
+    QPainter p(this);
+    p.setPen(Qt::gray);
+
+    int visibleWidgetCount = 0;
+    std::vector<QRect> visibleRects;
+
+    for (int i = 0; i < inner_layout.count(); ++i) {
+      QWidget *widget = inner_layout.itemAt(i)->widget();
+      if (widget && widget->isVisible()) {
+        visibleWidgetCount++;
+        visibleRects.push_back(inner_layout.itemAt(i)->geometry());
+      }
+    }
+
+    for (int i = 0; i < visibleWidgetCount - 1; ++i) {
+      int bottom = visibleRects[i].bottom() + inner_layout.spacing() / 2;
+      p.drawLine(visibleRects[i].left() + 40, bottom, visibleRects[i].right() - 40, bottom);
+    }
+  }
+  QVBoxLayout outer_layout;
+  QVBoxLayout inner_layout;
+};
+
+class FrogPilotDualParamControl : public QFrame {
+  Q_OBJECT
+
+public:
+  FrogPilotDualParamControl(ParamControl *control1, ParamControl *control2, QWidget *parent = nullptr, bool split=false)
+    : QFrame(parent) {
+    QHBoxLayout *hlayout = new QHBoxLayout(this);
+
+    control1->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
+    control1->setMaximumWidth(split ? 850 : 700);
+
+    control2->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
+    control2->setMaximumWidth(split ? 700 : 850);
+
+    hlayout->addWidget(control1);
+    hlayout->addWidget(control2);
+  }
+};
+
+class FrogPilotButtonControl : public AbstractControl {
+  Q_OBJECT
+
+public:
+  FrogPilotButtonControl(const QString &title, const QString &text, const QString &desc = "", QWidget *parent = nullptr);
+  inline void setText(const QString &text) { btn.setText(text); }
+  inline QString text() const { return btn.text(); }
+
+signals:
+  void clicked();
+
+public slots:
+  void setEnabled(bool enabled) { btn.setEnabled(enabled); }
+
+private:
+  QPushButton btn;
+};
+
+class FrogPilotButtonIconControl : public AbstractControl {
+  Q_OBJECT
+
+public:
+  FrogPilotButtonIconControl(const QString &title, const QString &text, const QString &desc = "", const QString &icon = "", QWidget *parent = nullptr);
+  inline void setText(const QString &text) { btn.setText(text); }
+  inline QString text() const { return btn.text(); }
+
+signals:
+  void clicked();
+
+public slots:
+  void setEnabled(bool enabled) { btn.setEnabled(enabled); }
+
+private:
+  QPushButton btn;
+};
+
+class FrogPilotButtonParamControl : public ParamControl {
+  Q_OBJECT
+public:
+  FrogPilotButtonParamControl(const QString &param, const QString &title, const QString &desc, const QString &icon,
+                              const std::vector<QString> &button_texts, const int minimum_button_width = 225)
+    : ParamControl(param, title, desc, icon) {
+    const QString style = R"(
+      QPushButton {
+        border-radius: 50px;
+        font-size: 40px;
+        font-weight: 500;
+        height:100px;
+        padding: 0 25 0 25;
+        color: #E4E4E4;
+        background-color: #393939;
+      }
+      QPushButton:pressed {
+        background-color: #4a4a4a;
+      }
+      QPushButton:checked:enabled {
+        background-color: #33Ab4C;
+      }
+      QPushButton:disabled {
+        color: #33E4E4E4;
+      }
+    )";
+
+    key = param.toStdString();
+    int value = atoi(params.get(key).c_str());
+
+    button_group = new QButtonGroup(this);
+    button_group->setExclusive(true);
+    for (size_t i = 0; i < button_texts.size(); i++) {
+      QPushButton *button = new QPushButton(button_texts[i], this);
+      button->setCheckable(true);
+      button->setChecked(i == value);
+      button->setStyleSheet(style);
+      button->setMinimumWidth(minimum_button_width);
+      hlayout->addWidget(button);
+      button_group->addButton(button, i);
+    }
+
+    QObject::connect(button_group, QOverload<int, bool>::of(&QButtonGroup::buttonToggled), [=](int id, bool checked) {
+      if (checked) {
+        params.put(key, std::to_string(id));
+        refresh();
+        emit buttonClicked(id);
+      }
+    });
+
+    toggle.hide();
+  }
+
+  void setEnabled(bool enable) {
+    for (auto btn : button_group->buttons()) {
+      btn->setEnabled(enable);
+    }
+  }
+
+signals:
+  void buttonClicked(int id);
+
+private:
+  std::string key;
+  Params params;
+  QButtonGroup *button_group;
+};
+
+class FrogPilotButtonsControl : public ParamControl {
+  Q_OBJECT
+public:
+  FrogPilotButtonsControl(const QString &title, const QString &desc, const QString &icon,
+                          const std::vector<QString> &button_texts, const int minimum_button_width = 225)
+    : ParamControl("", title, desc, icon) {
+    const QString style = R"(
+      QPushButton {
+        border-radius: 50px;
+        font-size: 40px;
+        font-weight: 500;
+        height: 100px;
+        padding: 0 25px 0 25px;
+        color: #E4E4E4;
+        background-color: #393939;
+      }
+      QPushButton:pressed {
+        background-color: #33Ab4C;
+      }
+      QPushButton:disabled {
+        color: #33E4E4E4;
+      }
+    )";
+
+    button_group = new QButtonGroup(this);
+
+    for (size_t i = 0; i < button_texts.size(); i++) {
+      QPushButton *button = new QPushButton(button_texts[i], this);
+      button->setStyleSheet(style);
+      button->setMinimumWidth(minimum_button_width);
+      hlayout->addWidget(button);
+      button_group->addButton(button, static_cast<int>(i));
+
+      connect(button, &QPushButton::clicked, this, [this, i]() {
+        emit buttonClicked(static_cast<int>(i));
+      });
+    }
+
+    toggle.hide();
+  }
+
+signals:
+  void buttonClicked(int id);
+
+private:
+  QButtonGroup *button_group;
+};
+
+class FrogPilotButtonsParamControl : public ParamControl {
+  Q_OBJECT
+public:
+  FrogPilotButtonsParamControl(const QString &param, const QString &title, const QString &desc, const QString &icon,
+                               const std::vector<std::pair<QString, QString>> &button_params)
+    : ParamControl(param, title, desc, icon) {
+    const QString style = R"(
+      QPushButton {
+        border-radius: 50px;
+        font-size: 40px;
+        font-weight: 500;
+        height:100px;
+        padding: 0 25 0 25;
+        color: #E4E4E4;
+        background-color: #393939;
+      }
+      QPushButton:pressed {
+        background-color: #4a4a4a;
+      }
+      QPushButton:checked:enabled {
+        background-color: #33Ab4C;
+      }
+      QPushButton:disabled {
+        color: #33E4E4E4;
+      }
+    )";
+
+    button_group = new QButtonGroup(this);
+    button_group->setExclusive(true);
+
+    for (const auto &param_pair : button_params) {
+      const QString &param_toggle = param_pair.first;
+      const QString &button_text = param_pair.second;
+
+      QPushButton *button = new QPushButton(button_text, this);
+      button->setCheckable(true);
+
+      bool value = params.getBool(param_toggle.toStdString());
+      button->setChecked(value);
+      button->setStyleSheet(style);
+      button->setMinimumWidth(225);
+      hlayout->addWidget(button);
+
+      QObject::connect(button, &QPushButton::toggled, this, [=](bool checked) {
+        if (checked) {
+          for (const auto &inner_param_pair : button_params) {
+            const QString &inner_param = inner_param_pair.first;
+            params.putBool(inner_param.toStdString(), inner_param == param_toggle);
+          }
+          refresh();
+          emit buttonClicked();
+        }
+      });
+
+      button_group->addButton(button);
+    }
+
+    toggle.hide();
+  }
+
+  void setEnabled(bool enable) {
+    for (auto btn : button_group->buttons()) {
+      btn->setEnabled(enable);
+    }
+  }
+
+signals:
+  void buttonClicked();
+
+private:
+  Params params;
+  QButtonGroup *button_group;
+};
+
+class FrogPilotParamManageControl : public ParamControl {
+  Q_OBJECT
+
+public:
+  FrogPilotParamManageControl(const QString &param, const QString &title, const QString &desc, const QString &icon, QWidget *parent = nullptr, bool hideToggle = false)
+    : ParamControl(param, title, desc, icon, parent),
+      hideToggle(hideToggle),
+      key(param.toStdString()),
+      manageButton(new ButtonControl(tr(""), tr("MANAGE"), tr(""))) {
+    hlayout->insertWidget(hlayout->indexOf(&toggle) - 1, manageButton);
+
+    connect(this, &ToggleControl::toggleFlipped, this, [this](bool state) {
+      refresh();
+    });
+
+    connect(manageButton, &ButtonControl::clicked, this, &FrogPilotParamManageControl::manageButtonClicked);
+
+    if (hideToggle) {
+      toggle.hide();
+    }
+  }
+
+  void refresh() {
+    ParamControl::refresh();
+    manageButton->setVisible(params.getBool(key) || hideToggle);
+  }
+
+  void showEvent(QShowEvent *event) override {
+    ParamControl::showEvent(event);
+    refresh();
+  }
+
+signals:
+  void manageButtonClicked();
+
+private:
+  bool hideToggle;
+  std::string key;
+  Params params;
+  ButtonControl *manageButton;
+};
+
+class FrogPilotParamToggleControl : public ParamControl {
+  Q_OBJECT
+public:
+  FrogPilotParamToggleControl(const QString &param, const QString &title, const QString &desc,
+                              const QString &icon, const std::vector<QString> &button_params,
+                              const std::vector<QString> &button_texts, QWidget *parent = nullptr,
+                              const int minimum_button_width = 225)
+    : ParamControl(param, title, desc, icon, parent) {
+
+    key = param.toStdString();
+
+    connect(this, &ToggleControl::toggleFlipped, this, [this](bool state) {
+      refreshButtons(state);
+    });
+
+    const QString style = R"(
+      QPushButton {
+        border-radius: 50px;
+        font-size: 40px;
+        font-weight: 500;
+        height:100px;
+        padding: 0 25 0 25;
+        color: #E4E4E4;
+        background-color: #393939;
+      }
+      QPushButton:pressed {
+        background-color: #4a4a4a;
+      }
+      QPushButton:checked:enabled {
+        background-color: #33Ab4C;
+      }
+      QPushButton:disabled {
+        color: #33E4E4E4;
+      }
+    )";
+
+    button_group = new QButtonGroup(this);
+    button_group->setExclusive(false);
+    this->button_params = button_params;
+
+    for (int i = 0; i < button_texts.size(); ++i) {
+      QPushButton *button = new QPushButton(button_texts[i], this);
+      button->setCheckable(true);
+      button->setStyleSheet(style);
+      button->setMinimumWidth(minimum_button_width);
+      button_group->addButton(button, i);
+
+      connect(button, &QPushButton::clicked, [this, i](bool checked) {
+        params.putBool(this->button_params[i].toStdString(), checked);
+        button_group->button(i)->setChecked(checked);
+        emit buttonClicked(checked);
+      });
+
+      hlayout->insertWidget(hlayout->indexOf(&toggle) - 1, button);
+    }
+  }
+
+  void refresh() {
+    bool state = params.getBool(key);
+    if (state != toggle.on) {
+      toggle.togglePosition();
+    }
+
+    refreshButtons(state);
+    updateButtonStates();
+  }
+
+  void refreshButtons(bool state) {
+    for (QAbstractButton *button : button_group->buttons()) {
+      button->setVisible(state);
+    }
+  }
+
+  void updateButtonStates() {
+    for (int i = 0; i < button_group->buttons().size(); ++i) {
+      bool checked = params.getBool(button_params[i].toStdString());
+      QAbstractButton *button = button_group->button(i);
+      if (button) {
+        button->setChecked(checked);
+      }
+    }
+  }
+
+  void showEvent(QShowEvent *event) override {
+    refresh();
+    QWidget::showEvent(event);
+  }
+
+signals:
+  void buttonClicked(const bool checked);
+
+private:
+  std::string key;
+  Params params;
+  QButtonGroup *button_group;
+  std::vector<QString> button_params;
+};
+
+class FrogPilotParamValueControl : public ParamControl {
+  Q_OBJECT
+
+public:
+  FrogPilotParamValueControl(const QString &param, const QString &title, const QString &desc, const QString &icon,
+                             const float &minValue, const float &maxValue, const std::map<int, QString> &valueLabels,
+                             QWidget *parent = nullptr, const bool &loop = true, const QString &label = "",
+                             const float &division = 1.0f, const float &intervals = 1.0f)
+      : ParamControl(param, title, desc, icon, parent),
+        minValue(minValue), maxValue(maxValue), valueLabelMappings(valueLabels), loop(loop), labelText(label),
+        division(division), previousValue(0.0f), value(0.0f) {
+    key = param.toStdString();
+
+    valueLabel = new QLabel(this);
+    hlayout->addWidget(valueLabel);
+
+    QPushButton *decrementButton = createButton("-", this);
+    QPushButton *incrementButton = createButton("+", this);
+
+    hlayout->addWidget(decrementButton);
+    hlayout->addWidget(incrementButton);
+
+    countdownTimer = new QTimer(this);
+    countdownTimer->setInterval(150);
+    countdownTimer->setSingleShot(true);
+
+    connect(countdownTimer, &QTimer::timeout, this, &FrogPilotParamValueControl::handleTimeout);
+
+    connect(decrementButton, &QPushButton::pressed, this, [=]() { updateValue(-intervals); });
+    connect(incrementButton, &QPushButton::pressed, this, [=]() { updateValue(intervals); });
+
+    connect(decrementButton, &QPushButton::released, this, &FrogPilotParamValueControl::restartTimer);
+    connect(incrementButton, &QPushButton::released, this, &FrogPilotParamValueControl::restartTimer);
+
+    toggle.hide();
+  }
+
+  void restartTimer() {
+    countdownTimer->stop();
+    countdownTimer->start();
+  }
+
+  void handleTimeout() {
+    previousValue = value;
+  }
+
+  void updateValue(float increment) {
+    if (std::fabs(previousValue - value) > 5.0f && std::fmod(value, 5.0f) == 0.0f) {
+      increment *= 5;
+    }
+    value += increment;
+
+    if (loop) {
+      if (value < minValue) value = maxValue;
+      else if (value > maxValue) value = minValue;
+    } else {
+      value = std::max(minValue, std::min(maxValue, value));
+    }
+
+    params.putFloat(key, value);
+    refresh();
+    emit valueChanged(value);
+  }
+
+  void refresh() {
+    value = params.getFloat(key);
+
+    QString text;
+    auto it = valueLabelMappings.find(value);
+
+    if (division > 1.0f) {
+      text = QString::number(value / division, 'g', division >= 10.0f ? 4 : 3);
+    } else {
+      if (it != valueLabelMappings.end()) {
+        text = it->second;
+      } else {
+        text = QString::number(value, 'g', 4);
+      }
+    }
+
+    if (!labelText.isEmpty()) {
+      text += labelText;
+    }
+
+    valueLabel->setText(text);
+    valueLabel->setStyleSheet("QLabel { color: #E0E879; }");
+  }
+
+  void updateControl(float newMinValue, float newMaxValue, const QString &newLabel, float newDivision = 1.0f) {
+    minValue = newMinValue;
+    maxValue = newMaxValue;
+    labelText = newLabel;
+    division = newDivision;
+  }
+
+  void showEvent(QShowEvent *event) override {
+    refresh();
+    previousValue = value;
+  }
+
+signals:
+  void valueChanged(float value);
+
+private:
+  bool loop;
+  float division;
+  float maxValue;
+  float minValue;
+  float previousValue;
+  float value;
+  QLabel *valueLabel;
+  QString labelText;
+  std::map<int, QString> valueLabelMappings;
+  std::string key;
+  Params params;
+  QTimer *countdownTimer;
+
+  QPushButton *createButton(const QString &text, QWidget *parent) {
+    QPushButton *button = new QPushButton(text, parent);
+    button->setFixedSize(150, 100);
+    button->setAutoRepeat(true);
+    button->setAutoRepeatInterval(150);
+    button->setAutoRepeatDelay(500);
+    button->setStyleSheet(R"(
+      QPushButton {
+        border-radius: 50px;
+        font-size: 50px;
+        font-weight: 500;
+        height: 100px;
+        padding: 0 25 0 25;
+        color: #E4E4E4;
+        background-color: #393939;
+      }
+      QPushButton:pressed {
+        background-color: #4a4a4a;
+      }
+    )");
+    return button;
+  }
+};
+
+class FrogPilotParamValueToggleControl : public ParamControl {
+  Q_OBJECT
+
+public:
+  FrogPilotParamValueToggleControl(const QString &param, const QString &title, const QString &desc, const QString &icon,
+                          const int &minValue, const int &maxValue, const std::map<int, QString> &valueLabels,
+                          QWidget *parent = nullptr, const bool &loop = true, const QString &label = "", const int &division = 1,
+                          const std::vector<QString> &button_params = std::vector<QString>(), const std::vector<QString> &button_texts = std::vector<QString>(),
+                          const int minimum_button_width = 225)
+    : ParamControl(param, title, desc, icon, parent),
+      minValue(minValue), maxValue(maxValue), valueLabelMappings(valueLabels), loop(loop), labelText(label), division(division) {
+        key = param.toStdString();
+
+        const QString style = R"(
+          QPushButton {
+            border-radius: 50px;
+            font-size: 40px;
+            font-weight: 500;
+            height:100px;
+            padding: 0 25 0 25;
+            color: #E4E4E4;
+            background-color: #393939;
+          }
+          QPushButton:pressed {
+            background-color: #4a4a4a;
+          }
+          QPushButton:checked:enabled {
+            background-color: #33Ab4C;
+          }
+          QPushButton:disabled {
+            color: #33E4E4E4;
+          }
+        )";
+
+        button_group = new QButtonGroup(this);
+        button_group->setExclusive(false);
+
+        std::map<QString, bool> paramState;
+        for (const QString &button_param : button_params) {
+          paramState[button_param] = params.getBool(button_param.toStdString());
+        }
+
+        for (int i = 0; i < button_texts.size(); ++i) {
+          QPushButton *button = new QPushButton(button_texts[i], this);
+          button->setCheckable(true);
+          button->setChecked(paramState[button_params[i]]);
+          button->setStyleSheet(style);
+          button->setMinimumWidth(minimum_button_width);
+          button_group->addButton(button, i);
+
+          connect(button, &QPushButton::clicked, [this, button_params, i](bool checked) {
+            params.putBool(button_params[i].toStdString(), checked);
+            button_group->button(i)->setChecked(checked);
+          });
+
+          hlayout->addWidget(button);
+        }
+
+        valueLabel = new QLabel(this);
+        hlayout->addWidget(valueLabel);
+
+        QPushButton *decrementButton = createButton("-", this);
+        QPushButton *incrementButton = createButton("+", this);
+
+        hlayout->addWidget(decrementButton);
+        hlayout->addWidget(incrementButton);
+
+        connect(decrementButton, &QPushButton::clicked, this, [=]() {
+          updateValue(-1);
+        });
+
+        connect(incrementButton, &QPushButton::clicked, this, [=]() {
+          updateValue(1);
+        });
+
+        toggle.hide();
+      }
+
+  void updateValue(int increment) {
+    value = value + increment;
+
+    if (loop) {
+      if (value < minValue) value = maxValue;
+      else if (value > maxValue) value = minValue;
+    } else {
+      value = std::max(minValue, std::min(maxValue, value));
+    }
+
+    params.putInt(key, value);
+    refresh();
+    emit valueChanged(value);
+  }
+
+  void refresh() {
+    value = params.getInt(key);
+
+    QString text;
+    auto it = valueLabelMappings.find(value);
+    if (division > 1) {
+      text = QString::number(value / (division * 1.0), 'g');
+    } else {
+      text = it != valueLabelMappings.end() ? it->second : QString::number(value);
+    }
+    if (!labelText.isEmpty()) {
+      text += labelText;
+    }
+    valueLabel->setText(text);
+    valueLabel->setStyleSheet("QLabel { color: #E0E879; }");
+  }
+
+  void updateControl(int newMinValue, int newMaxValue, const QString &newLabel, int newDivision) {
+    minValue = newMinValue;
+    maxValue = newMaxValue;
+    labelText = newLabel;
+    division = newDivision;
+  }
+
+  void showEvent(QShowEvent *event) override {
+    refresh();
+  }
+
+signals:
+  void valueChanged(int value);
+
+private:
+  bool loop;
+  int division;
+  int maxValue;
+  int minValue;
+  int value;
+  QButtonGroup *button_group;
+  QLabel *valueLabel;
+  QString labelText;
+  std::map<int, QString> valueLabelMappings;
+  std::string key;
+  Params params;
+
+  QPushButton *createButton(const QString &text, QWidget *parent) {
+    QPushButton *button = new QPushButton(text, parent);
+    button->setFixedSize(150, 100);
+    button->setAutoRepeat(true);
+    button->setAutoRepeatInterval(150);
+    button->setAutoRepeatDelay(350);
+    button->setStyleSheet(R"(
+      QPushButton {
+        border-radius: 50px;
+        font-size: 50px;
+        font-weight: 500;
+        height: 100px;
+        padding: 0 25 0 25;
+        color: #E4E4E4;
+        background-color: #393939;
+      }
+      QPushButton:pressed {
+        background-color: #4a4a4a;
+      }
+    )");
+    return button;
+  }
+};

selfdrive/frogpilot/ui/vehicle_settings.cc

@@ -0,0 +1,88 @@
+#include "selfdrive/frogpilot/ui/vehicle_settings.h"
+
+FrogPilotVehiclesPanel::FrogPilotVehiclesPanel(SettingsWindow *parent) : FrogPilotListWidget(parent) {
+  std::vector<std::tuple<QString, QString, QString, QString>> vehicleToggles {
+    {"LongitudinalTune", "Longitudinal Tune", "Use a custom Toyota longitudinal tune.\n\nCydia = More focused on TSS-P vehicles but works for all Toyotas\n\nDragonPilot = Focused on TSS2 vehicles\n\nFrogPilot = Takes the best of both worlds with some personal tweaks focused around my 2019 Lexus ES 350", ""},
+  };
+
+  for (const auto &[param, title, desc, icon] : vehicleToggles) {
+    ParamControl *toggle;
+
+    if (param == "LongitudinalTune") {
+      std::vector<std::pair<QString, QString>> tuneOptions{
+        {"StockTune", tr("Stock")},
+      };
+      toggle = new FrogPilotButtonsParamControl(param, title, desc, icon, tuneOptions);
+
+      QObject::connect(static_cast<FrogPilotButtonsParamControl*>(toggle), &FrogPilotButtonsParamControl::buttonClicked, [this]() {
+        if (started) {
+          if (FrogPilotConfirmationDialog::toggle("Reboot required to take effect.", "Reboot Now", this)) {
+            Hardware::soft_reboot();
+          }
+        }
+      });
+
+    } else {
+      toggle = new ParamControl(param, title, desc, icon, this);
+    }
+
+    toggle->setVisible(false);
+    addItem(toggle);
+    toggles[param.toStdString()] = toggle;
+
+    QObject::connect(toggle, &ToggleControl::toggleFlipped, [this]() {
+      updateToggles();
+    });
+
+    QObject::connect(toggle, &AbstractControl::showDescriptionEvent, [this]() {
+      update();
+    });
+  }
+
+  std::set<std::string> rebootKeys = {};
+  for (const std::string &key : rebootKeys) {
+    QObject::connect(toggles[key], &ToggleControl::toggleFlipped, [this]() {
+      if (started) {
+        if (FrogPilotConfirmationDialog::toggle("Reboot required to take effect.", "Reboot Now", this)) {
+          Hardware::soft_reboot();
+        }
+      }
+    });
+  }
+
+  QObject::connect(uiState(), &UIState::uiUpdate, this, &FrogPilotVehiclesPanel::updateState);
+}
+
+void FrogPilotVehiclesPanel::updateState(const UIState &s) {
+  started = s.scene.started;
+}
+
+void FrogPilotVehiclesPanel::updateToggles() {
+  std::thread([this]() {
+    paramsMemory.putBool("FrogPilotTogglesUpdated", true);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    paramsMemory.putBool("FrogPilotTogglesUpdated", false);
+  }).detach();
+}
+
+void FrogPilotVehiclesPanel::setToggles() {
+  bool gm = false;
+  bool subaru false;
+  bool toyota = false;
+
+  for (auto &[key, toggle] : toggles) {
+    if (toggle) {
+      toggle->setVisible(false);
+
+      if (gm) {
+        toggle->setVisible(gmKeys.find(key.c_str()) != gmKeys.end());
+      } else if (subaru) {
+        toggle->setVisible(subaruKeys.find(key.c_str()) != subaruKeys.end());
+      } else if (toyota) {
+        toggle->setVisible(toyotaKeys.find(key.c_str()) != toyotaKeys.end());
+      }
+    }
+  }
+
+  update();
+}

selfdrive/frogpilot/ui/vehicle_settings.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <set>
+
+#include <QStringList>
+
+#include "selfdrive/frogpilot/ui/frogpilot_ui_functions.h"
+#include "selfdrive/ui/qt/offroad/settings.h"
+#include "selfdrive/ui/ui.h"
+
+class FrogPilotVehiclesPanel : public FrogPilotListWidget {
+  Q_OBJECT
+
+public:
+  explicit FrogPilotVehiclesPanel(SettingsWindow *parent);
+
+private:
+  void setToggles();
+  void updateState(const UIState &s);
+  void updateToggles();
+
+  std::map<std::string, ParamControl*> toggles;
+
+  std::set<QString> gmKeys = {};
+  std::set<QString> subaruKeys = {};
+  std::set<QString> toyotaKeys = {"LongitudinalTune"};
+
+  Params params;
+  Params paramsMemory{"/dev/shm/params"};
+
+  bool started = false;
+};

selfdrive/frogpilot/ui/visual_settings.cc

@@ -0,0 +1,156 @@
+#include "selfdrive/frogpilot/ui/visual_settings.h"
+
+FrogPilotVisualsPanel::FrogPilotVisualsPanel(SettingsWindow *parent) : FrogPilotListWidget(parent) {
+  const std::vector<std::tuple<QString, QString, QString, QString>> visualToggles {
+    {"CustomAlerts", "Custom Alerts", "Enable custom alerts for various logic or situational changes.", "../frogpilot/assets/toggle_icons/icon_green_light.png"},
+
+    {"CustomUI", "Custom Onroad UI", "Customize the Onroad UI with some additional visual functions.", "../assets/offroad/icon_road.png"},
+
+    {"QOLVisuals", "Quality of Life", "Miscellaneous quality of life changes to improve your overall openpilot experience.", "../frogpilot/assets/toggle_icons/quality_of_life.png"},
+  };
+
+  for (const auto &[param, title, desc, icon] : visualToggles) {
+    ParamControl *toggle;
+
+    if (param == "CustomAlerts") {
+      FrogPilotParamManageControl *customAlertsToggle = new FrogPilotParamManageControl(param, title, desc, icon, this);
+      QObject::connect(customAlertsToggle, &FrogPilotParamManageControl::manageButtonClicked, this, [this]() {
+        parentToggleClicked();
+        for (auto &[key, toggle] : toggles) {
+          toggle->setVisible(customAlertsKeys .find(key.c_str()) != customAlertsKeys .end());
+        }
+      });
+      toggle = customAlertsToggle;
+
+    } else if (param == "CustomUI") {
+      FrogPilotParamManageControl *customUIToggle = new FrogPilotParamManageControl(param, title, desc, icon, this);
+      QObject::connect(customUIToggle, &FrogPilotParamManageControl::manageButtonClicked, this, [this]() {
+        parentToggleClicked();
+        for (auto &[key, toggle] : toggles) {
+          toggle->setVisible(customOnroadUIKeys.find(key.c_str()) != customOnroadUIKeys.end());
+        }
+      });
+      toggle = customUIToggle;
+
+    } else if (param == "QOLVisuals") {
+      FrogPilotParamManageControl *qolToggle = new FrogPilotParamManageControl(param, title, desc, icon, this);
+      QObject::connect(qolToggle, &FrogPilotParamManageControl::manageButtonClicked, this, [this]() {
+        parentToggleClicked();
+        for (auto &[key, toggle] : toggles) {
+          toggle->setVisible(qolKeys.find(key.c_str()) != qolKeys.end());
+        }
+      });
+      toggle = qolToggle;
+
+    } else {
+      toggle = new ParamControl(param, title, desc, icon, this);
+    }
+
+    addItem(toggle);
+    toggles[param.toStdString()] = toggle;
+
+    QObject::connect(toggle, &ToggleControl::toggleFlipped, [this]() {
+      updateToggles();
+    });
+
+    QObject::connect(static_cast<FrogPilotButtonParamControl*>(toggle), &FrogPilotButtonParamControl::buttonClicked, [this]() {
+      updateToggles();
+    });
+
+    QObject::connect(static_cast<FrogPilotParamValueControl*>(toggle), &FrogPilotParamValueControl::valueChanged, [this]() {
+      updateToggles();
+    });
+
+    QObject::connect(toggle, &AbstractControl::showDescriptionEvent, [this]() {
+      update();
+    });
+
+    QObject::connect(static_cast<FrogPilotParamManageControl*>(toggle), &FrogPilotParamManageControl::manageButtonClicked, [this]() {
+      update();
+    });
+  }
+
+  std::set<std::string> rebootKeys = {""};
+  for (const std::string &key : rebootKeys) {
+    QObject::connect(toggles[key], &ToggleControl::toggleFlipped, [this, key]() {
+      if (started) {
+        if (FrogPilotConfirmationDialog::toggle("Reboot required to take effect.", "Reboot Now", this)) {
+          Hardware::soft_reboot();
+        }
+      }
+    });
+  }
+
+  QObject::connect(device(), &Device::interactiveTimeout, this, &FrogPilotVisualsPanel::hideSubToggles);
+  QObject::connect(parent, &SettingsWindow::closeParentToggle, this, &FrogPilotVisualsPanel::hideSubToggles);
+  QObject::connect(parent, &SettingsWindow::closeSubParentToggle, this, &FrogPilotVisualsPanel::hideSubSubToggles);
+  QObject::connect(parent, &SettingsWindow::updateMetric, this, &FrogPilotVisualsPanel::updateMetric);
+  QObject::connect(uiState(), &UIState::uiUpdate, this, &FrogPilotVisualsPanel::updateState);
+
+  hideSubToggles();
+  updateMetric();
+}
+
+void FrogPilotVisualsPanel::updateState(const UIState &s) {
+  started = s.scene.started;
+}
+
+void FrogPilotVisualsPanel::updateToggles() {
+  std::thread([this]() {
+    paramsMemory.putBool("FrogPilotTogglesUpdated", true);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    paramsMemory.putBool("FrogPilotTogglesUpdated", false);
+  }).detach();
+}
+
+void FrogPilotVisualsPanel::updateMetric() {
+  bool previousIsMetric = isMetric;
+  isMetric = params.getBool("IsMetric");
+
+  if (isMetric != previousIsMetric) {
+    double distanceConversion = isMetric ? INCH_TO_CM : CM_TO_INCH;
+    double speedConversion = isMetric ? FOOT_TO_METER : METER_TO_FOOT;
+  }
+
+  if (isMetric) {
+  } else {
+  }
+
+  previousIsMetric = isMetric;
+}
+
+void FrogPilotVisualsPanel::parentToggleClicked() {
+  openParentToggle();
+}
+
+void FrogPilotVisualsPanel::subParentToggleClicked() {
+  openSubParentToggle();
+}
+
+void FrogPilotVisualsPanel::hideSubToggles() {
+  for (auto &[key, toggle] : toggles) {
+    bool subToggles = alertVolumeControlKeys.find(key.c_str()) != alertVolumeControlKeys.end() ||
+                      customAlertsKeys.find(key.c_str()) != customAlertsKeys.end() ||
+                      customOnroadUIKeys.find(key.c_str()) != customOnroadUIKeys.end() ||
+                      customThemeKeys.find(key.c_str()) != customThemeKeys.end() ||
+                      modelUIKeys.find(key.c_str()) != modelUIKeys.end() ||
+                      qolKeys.find(key.c_str()) != qolKeys.end();
+    toggle->setVisible(!subToggles);
+  }
+
+  closeParentToggle();
+}
+
+void FrogPilotVisualsPanel::hideSubSubToggles() {
+  for (auto &[key, toggle] : toggles) {
+    bool isVisible = false;
+    toggle->setVisible(isVisible);
+  }
+
+  closeSubParentToggle();
+  update();
+}
+
+void FrogPilotVisualsPanel::hideEvent(QHideEvent *event) {
+  hideSubToggles();
+}

selfdrive/frogpilot/ui/visual_settings.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <set>
+
+#include "selfdrive/frogpilot/ui/frogpilot_ui_functions.h"
+#include "selfdrive/ui/qt/offroad/settings.h"
+#include "selfdrive/ui/ui.h"
+
+class FrogPilotVisualsPanel : public FrogPilotListWidget {
+  Q_OBJECT
+
+public:
+  explicit FrogPilotVisualsPanel(SettingsWindow *parent);
+
+signals:
+  void closeParentToggle();
+  void closeSubParentToggle();
+  void openParentToggle();
+  void openSubParentToggle();
+
+private:
+  void hideEvent(QHideEvent *event);
+  void hideSubToggles();
+  void hideSubSubToggles();
+  void parentToggleClicked();
+  void subParentToggleClicked();
+  void updateMetric();
+  void updateState(const UIState &s);
+  void updateToggles();
+
+  std::set<QString> alertVolumeControlKeys = {};
+  std::set<QString> customAlertsKeys = {};
+  std::set<QString> customOnroadUIKeys = {};
+  std::set<QString> customThemeKeys = {};
+  std::set<QString> modelUIKeys = {};
+  std::set<QString> qolKeys = {};
+
+  std::map<std::string, ParamControl*> toggles;
+
+  Params params;
+  Params paramsMemory{"/dev/shm/params"};
+
+  bool isMetric = params.getBool("IsMetric");
+  bool started = false;
+};