wip

selfdrive/ui/qt/maps/map.cc

@@ -18,7 +18,7 @@ const float MAX_PITCH = 50;
 const float MIN_PITCH = 0;
 const float MAP_SCALE = 2;
 
-MapWindow::MapWindow(const QMapboxGLSettings &settings) : m_settings(settings), velocity_filter(0, 10, 0.05, false) {
+MapWindow::MapWindow(const QMapLibre::Settings &settings) : m_settings(settings), velocity_filter(0, 10, 0.05, false) {
   QObject::connect(uiState(), &UIState::uiUpdate, this, &MapWindow::updateState);
 
   map_overlay = new QWidget (this);
@@ -57,10 +57,10 @@ void MapWindow::initLayers() {
   if (!m_map->layerExists("modelPathLayer")) {
     qDebug() << "Initializing modelPathLayer";
     QVariantMap modelPath;
-    modelPath["id"] = "modelPathLayer";
+    //modelPath["id"] = "modelPathLayer";
     modelPath["type"] = "line";
     modelPath["source"] = "modelPathSource";
-    m_map->addLayer(modelPath);
+    m_map->addLayer("modelPathLayer", modelPath);
     m_map->setPaintProperty("modelPathLayer", "line-color", QColor("red"));
     m_map->setPaintProperty("modelPathLayer", "line-width", 5.0);
     m_map->setLayoutProperty("modelPathLayer", "line-cap", "round");
@@ -68,10 +68,9 @@ void MapWindow::initLayers() {
   if (!m_map->layerExists("navLayer")) {
     qDebug() << "Initializing navLayer";
     QVariantMap nav;
-    nav["id"] = "navLayer";
     nav["type"] = "line";
     nav["source"] = "navSource";
-    m_map->addLayer(nav, "road-intersection");
+    m_map->addLayer("navLayer", nav, "road-intersection");
 
     QVariantMap transition;
     transition["duration"] = 400;  // ms
@@ -84,10 +83,9 @@ void MapWindow::initLayers() {
     qDebug() << "Initializing pinLayer";
     m_map->addImage("default_marker", QImage("../assets/navigation/default_marker.svg"));
     QVariantMap pin;
-    pin["id"] = "pinLayer";
     pin["type"] = "symbol";
     pin["source"] = "pinSource";
-    m_map->addLayer(pin);
+    m_map->addLayer("pinLayer", pin);
     m_map->setLayoutProperty("pinLayer", "icon-pitch-alignment", "viewport");
     m_map->setLayoutProperty("pinLayer", "icon-image", "default_marker");
     m_map->setLayoutProperty("pinLayer", "icon-ignore-placement", true);
@@ -100,10 +98,9 @@ void MapWindow::initLayers() {
     m_map->addImage("label-arrow", QImage("../assets/images/triangle.svg"));
 
     QVariantMap carPos;
-    carPos["id"] = "carPosLayer";
     carPos["type"] = "symbol";
     carPos["source"] = "carPosSource";
-    m_map->addLayer(carPos);
+    m_map->addLayer("carPosLayer", carPos);
     m_map->setLayoutProperty("carPosLayer", "icon-pitch-alignment", "map");
     m_map->setLayoutProperty("carPosLayer", "icon-image", "label-arrow");
     m_map->setLayoutProperty("carPosLayer", "icon-size", 0.5);
@@ -112,7 +109,6 @@ void MapWindow::initLayers() {
     // TODO: remove, symbol-sort-key does not seem to matter outside of each layer
     m_map->setLayoutProperty("carPosLayer", "symbol-sort-key", 0);
   }
-
   if (!m_map->layerExists("buildingsLayer")) {
     qDebug() << "Initializing buildingsLayer";
     QVariantMap buildings;
@@ -121,7 +117,7 @@ void MapWindow::initLayers() {
     buildings["source-layer"] = "building";
     buildings["type"] = "fill-extrusion";
     buildings["minzoom"] = 15;
-    m_map->addLayer(buildings);
+    m_map->addLayer("buildingsLayer", buildings);
     m_map->setFilter("buildingsLayer", QVariantList({"==", "extrude", "true"}));
 
     QVariantList fillExtrusionHight = {
@@ -141,7 +137,7 @@ void MapWindow::initLayers() {
     };
 
     QVariantList fillExtrusionOpacity = {
-      "interpolate", 
+      "interpolate",
       QVariantList{"linear"},
       QVariantList{"zoom"},
       15, 0,
@@ -168,8 +164,7 @@ void MapWindow::updateState(const UIState &s) {
   if (sm.updated("modelV2")) {
     // set path color on change, and show map on rising edge of navigate on openpilot
     bool nav_enabled = sm["modelV2"].getModelV2().getNavEnabled() &&
-                       (sm["controlsState"].getControlsState().getEnabled() || sm["frogpilotCarControl"].getFrogpilotCarControl().getAlwaysOnLateral()) &&
-                       (!params.get("NavDestination").empty() || params.getInt("PrimeType") != 0);
+                       (sm["controlsState"].getControlsState().getEnabled() || sm["frogpilotCarControl"].getFrogpilotCarControl().getAlwaysOnLateral());
     if (nav_enabled != uiState()->scene.navigate_on_openpilot) {
       if (loaded_once) {
         m_map->setPaintProperty("navLayer", "line-color", getNavPathColor(nav_enabled));
@@ -194,12 +189,24 @@ void MapWindow::updateState(const UIState &s) {
     locationd_valid = (locationd_pos.getValid() && locationd_orientation.getValid() && locationd_velocity.getValid() && pos_accurate_enough);
 
     if (locationd_valid) {
-      last_position = QMapbox::Coordinate(locationd_pos.getValue()[0], locationd_pos.getValue()[1]);
+      last_position = QMapLibre::Coordinate(locationd_pos.getValue()[0], locationd_pos.getValue()[1]);
       last_bearing = RAD2DEG(locationd_orientation.getValue()[2]);
       velocity_filter.update(std::max(10.0, locationd_velocity.getValue()[0]));
     }
   }
 
+  // Credit to jakethesnake420
+  if (loaded_once && (sm.rcv_frame("uiPlan") != model_rcv_frame)) {
+    auto locationd_location = sm["liveLocationKalman"].getLiveLocationKalman();
+    auto model_path = model_to_collection(locationd_location.getCalibratedOrientationECEF(), locationd_location.getPositionECEF(), sm["uiPlan"].getUiPlan().getPosition());
+    QMapLibre::Feature model_path_feature(QMapLibre::Feature::LineStringType, model_path, {}, {});
+    QVariantMap modelV2Path;
+    modelV2Path["type"] =  "geojson";
+    modelV2Path["data"] = QVariant::fromValue<QMapLibre::Feature>(model_path_feature);
+    m_map->updateSource("modelPathSource", modelV2Path);
+    model_rcv_frame = sm.rcv_frame("uiPlan");
+  }
+
   if (sm.updated("navRoute") && sm["navRoute"].getNavRoute().getCoordinates().size()) {
     auto nav_dest = coordinate_from_param("NavDestination");
     bool allow_open = std::exchange(last_valid_nav_dest, nav_dest) != nav_dest &&
@@ -231,10 +238,10 @@ void MapWindow::updateState(const UIState &s) {
   if (locationd_valid) {
     // Update current location marker
     auto point = coordinate_to_collection(*last_position);
-    QMapbox::Feature feature1(QMapbox::Feature::PointType, point, {}, {});
+    QMapLibre::Feature feature1(QMapLibre::Feature::PointType, point, {}, {});
     QVariantMap carPosSource;
     carPosSource["type"] = "geojson";
-    carPosSource["data"] = QVariant::fromValue<QMapbox::Feature>(feature1);
+    carPosSource["data"] = QVariant::fromValue<QMapLibre::Feature>(feature1);
     m_map->updateSource("carPosSource", carPosSource);
 
     // Map bearing isn't updated when interacting, keep location marker up to date
@@ -275,16 +282,40 @@ void MapWindow::updateState(const UIState &s) {
     qWarning() << "Updating navLayer with new route";
     auto route = sm["navRoute"].getNavRoute();
     auto route_points = capnp_coordinate_list_to_collection(route.getCoordinates());
-    QMapbox::Feature feature(QMapbox::Feature::LineStringType, route_points, {}, {});
+    QMapLibre::Feature feature(QMapLibre::Feature::LineStringType, route_points, {}, {});
     QVariantMap navSource;
     navSource["type"] = "geojson";
-    navSource["data"] = QVariant::fromValue<QMapbox::Feature>(feature);
+    navSource["data"] = QVariant::fromValue<QMapLibre::Feature>(feature);
     m_map->updateSource("navSource", navSource);
     m_map->setLayoutProperty("navLayer", "visibility", "visible");
 
     route_rcv_frame = sm.rcv_frame("navRoute");
     updateDestinationMarker();
   }
+
+  // Map Styling - Credit goes to OPKR!
+  int map_style = uiState()->scene.map_style;
+
+  if (map_style != previous_map_style) {
+    std::unordered_map<int, std::string> styleUrls = {
+      {0, "mapbox://styles/commaai/clkqztk0f00ou01qyhsa5bzpj"},  // Stock openpilot
+      {1, "mapbox://styles/mapbox/streets-v11"},  // Mapbox Streets
+      {2, "mapbox://styles/mapbox/outdoors-v11"},  // Mapbox Outdoors
+      {3, "mapbox://styles/mapbox/light-v10"},  // Mapbox Light
+      {4, "mapbox://styles/mapbox/dark-v10"},  // Mapbox Dark
+      {5, "mapbox://styles/mapbox/satellite-v9"},  // Mapbox Satellite
+      {6, "mapbox://styles/mapbox/satellite-streets-v11"},  // Mapbox Satellite Streets
+      {7, "mapbox://styles/mapbox/navigation-day-v1"},  // Mapbox Navigation Day
+      {8, "mapbox://styles/mapbox/navigation-night-v1"},  // Mapbox Navigation Night
+      {9, "mapbox://styles/mapbox/traffic-night-v2"},  // Mapbox Traffic Night
+      {10, "mapbox://styles/mike854/clt0hm8mw01ok01p4blkr27jp"},  // mike854's (Satellite hybrid)
+    };
+
+    std::unordered_map<int, std::string>::iterator it = styleUrls.find(map_style);
+    m_map->setStyleUrl(QString::fromStdString(it->second));
+  }
+
+  previous_map_style = map_style;
 }
 
 void MapWindow::setError(const QString &err_str) {
@@ -301,24 +332,24 @@ void MapWindow::resizeGL(int w, int h) {
 }
 
 void MapWindow::initializeGL() {
-  m_map.reset(new QMapboxGL(this, m_settings, size(), 1));
+  m_map.reset(new QMapLibre::Map(this, m_settings, size(), 1));
 
   if (last_position) {
     m_map->setCoordinateZoom(*last_position, MAX_ZOOM);
   } else {
-    m_map->setCoordinateZoom(QMapbox::Coordinate(64.31990695292795, -149.79038934046247), MIN_ZOOM);
+    m_map->setCoordinateZoom(QMapLibre::Coordinate(64.31990695292795, -149.79038934046247), MIN_ZOOM);
   }
 
   m_map->setMargins({0, 350, 0, 50});
   m_map->setPitch(MIN_PITCH);
   m_map->setStyleUrl("mapbox://styles/commaai/clkqztk0f00ou01qyhsa5bzpj");
 
-  QObject::connect(m_map.data(), &QMapboxGL::mapChanged, [=](QMapboxGL::MapChange change) {
+  QObject::connect(m_map.data(), &QMapLibre::Map::mapChanged, [=](QMapLibre::Map::MapChange change) {
     // set global animation duration to 0 ms so visibility changes are instant
-    if (change == QMapboxGL::MapChange::MapChangeDidFinishLoadingStyle) {
+    if (change == QMapLibre::Map::MapChange::MapChangeDidFinishLoadingStyle) {
       m_map->setTransitionOptions(0, 0);
     }
-    if (change == QMapboxGL::MapChange::MapChangeDidFinishLoadingMap) {
+    if (change == QMapLibre::Map::MapChange::MapChangeDidFinishLoadingMap) {
       loaded_once = true;
     }
   });
@@ -426,10 +457,10 @@ void MapWindow::updateDestinationMarker() {
   auto nav_dest = coordinate_from_param("NavDestination");
   if (nav_dest.has_value()) {
     auto point = coordinate_to_collection(*nav_dest);
-    QMapbox::Feature feature(QMapbox::Feature::PointType, point, {}, {});
+    QMapLibre::Feature feature(QMapLibre::Feature::PointType, point, {}, {});
     QVariantMap pinSource;
     pinSource["type"] = "geojson";
-    pinSource["data"] = QVariant::fromValue<QMapbox::Feature>(feature);
+    pinSource["data"] = QVariant::fromValue<QMapLibre::Feature>(feature);
     m_map->updateSource("pinSource", pinSource);
     m_map->setPaintProperty("pinLayer", "visibility", "visible");
   } else {

selfdrive/ui/qt/maps/map.h

@@ -6,7 +6,8 @@
 #include <QGestureEvent>
 #include <QLabel>
 #include <QMap>
-#include <QMapboxGL>
+#include <QMapLibre/Map>
+#include <QMapLibre/Settings>
 #include <QMouseEvent>
 #include <QOpenGLWidget>
 #include <QPixmap>
@@ -27,7 +28,7 @@ class MapWindow : public QOpenGLWidget {
   Q_OBJECT
 
 public:
-  MapWindow(const QMapboxGLSettings &);
+  MapWindow(const QMapLibre::Settings &);
   ~MapWindow();
 
 private:
@@ -35,8 +36,8 @@ private:
   void paintGL() final;
   void resizeGL(int w, int h) override;
 
-  QMapboxGLSettings m_settings;
-  QScopedPointer<QMapboxGL> m_map;
+  QMapLibre::Settings m_settings;
+  QScopedPointer<QMapLibre::Map> m_map;
 
   void initLayers();
 
@@ -56,8 +57,8 @@ private:
   int interaction_counter = 0;
 
   // Position
-  std::optional<QMapbox::Coordinate> last_valid_nav_dest;
-  std::optional<QMapbox::Coordinate> last_position;
+  std::optional<QMapLibre::Coordinate> last_valid_nav_dest;
+  std::optional<QMapLibre::Coordinate> last_position;
   std::optional<float> last_bearing;
   FirstOrderFilter velocity_filter;
   bool locationd_valid = false;
@@ -80,6 +81,10 @@ private:
   // FrogPilot variables
   Params params;
 
+  int previous_map_style;
+
+  uint64_t model_rcv_frame = 0;
+
 private slots:
   void updateState(const UIState &s);
 

selfdrive/ui/qt/maps/map_helpers.cc

@@ -16,24 +16,25 @@ QString get_mapbox_token() {
   return MAPBOX_TOKEN.isEmpty() ? CommaApi::create_jwt({}, 4 * 7 * 24 * 3600) : MAPBOX_TOKEN;
 }
 
-QMapboxGLSettings get_mapbox_settings() {
-  QMapboxGLSettings settings;
+QMapLibre::Settings get_mapbox_settings() {
+  QMapLibre::Settings settings;
+  settings.setProviderTemplate(QMapLibre::Settings::ProviderTemplate::MapboxProvider);
 
   if (!Hardware::PC()) {
     settings.setCacheDatabasePath(MAPS_CACHE_PATH);
     settings.setCacheDatabaseMaximumSize(100 * 1024 * 1024);
   }
   settings.setApiBaseUrl(MAPS_HOST);
-  settings.setAccessToken(get_mapbox_token());
+  settings.setApiKey(get_mapbox_token());
 
   return settings;
 }
 
-QGeoCoordinate to_QGeoCoordinate(const QMapbox::Coordinate &in) {
+QGeoCoordinate to_QGeoCoordinate(const QMapLibre::Coordinate &in) {
   return QGeoCoordinate(in.first, in.second);
 }
 
-QMapbox::CoordinatesCollections model_to_collection(
+QMapLibre::CoordinatesCollections model_to_collection(
   const cereal::LiveLocationKalman::Measurement::Reader &calibratedOrientationECEF,
   const cereal::LiveLocationKalman::Measurement::Reader &positionECEF,
   const cereal::XYZTData::Reader &line){
@@ -42,7 +43,7 @@ QMapbox::CoordinatesCollections model_to_collection(
   Eigen::Vector3d orient(calibratedOrientationECEF.getValue()[0], calibratedOrientationECEF.getValue()[1], calibratedOrientationECEF.getValue()[2]);
   Eigen::Matrix3d ecef_from_local = euler2rot(orient);
 
-  QMapbox::Coordinates coordinates;
+  QMapLibre::Coordinates coordinates;
   auto x = line.getX();
   auto y = line.getY();
   auto z = line.getZ();
@@ -52,28 +53,28 @@ QMapbox::CoordinatesCollections model_to_collection(
     coordinates.push_back({point_geodetic.lat, point_geodetic.lon});
   }
 
-  return {QMapbox::CoordinatesCollection{coordinates}};
+  return {QMapLibre::CoordinatesCollection{coordinates}};
 }
 
-QMapbox::CoordinatesCollections coordinate_to_collection(const QMapbox::Coordinate &c) {
-  QMapbox::Coordinates coordinates{c};
-  return {QMapbox::CoordinatesCollection{coordinates}};
+QMapLibre::CoordinatesCollections coordinate_to_collection(const QMapLibre::Coordinate &c) {
+  QMapLibre::Coordinates coordinates{c};
+  return {QMapLibre::CoordinatesCollection{coordinates}};
 }
 
-QMapbox::CoordinatesCollections capnp_coordinate_list_to_collection(const capnp::List<cereal::NavRoute::Coordinate>::Reader& coordinate_list) {
-  QMapbox::Coordinates coordinates;
+QMapLibre::CoordinatesCollections capnp_coordinate_list_to_collection(const capnp::List<cereal::NavRoute::Coordinate>::Reader& coordinate_list) {
+  QMapLibre::Coordinates coordinates;
   for (auto const &c : coordinate_list) {
     coordinates.push_back({c.getLatitude(), c.getLongitude()});
   }
-  return {QMapbox::CoordinatesCollection{coordinates}};
+  return {QMapLibre::CoordinatesCollection{coordinates}};
 }
 
-QMapbox::CoordinatesCollections coordinate_list_to_collection(const QList<QGeoCoordinate> &coordinate_list) {
-  QMapbox::Coordinates coordinates;
+QMapLibre::CoordinatesCollections coordinate_list_to_collection(const QList<QGeoCoordinate> &coordinate_list) {
+  QMapLibre::Coordinates coordinates;
   for (auto &c : coordinate_list) {
     coordinates.push_back({c.latitude(), c.longitude()});
   }
-  return {QMapbox::CoordinatesCollection{coordinates}};
+  return {QMapLibre::CoordinatesCollection{coordinates}};
 }
 
 QList<QGeoCoordinate> polyline_to_coordinate_list(const QString &polylineString) {
@@ -118,7 +119,7 @@ QList<QGeoCoordinate> polyline_to_coordinate_list(const QString &polylineString)
   return path;
 }
 
-std::optional<QMapbox::Coordinate> coordinate_from_param(const std::string &param) {
+std::optional<QMapLibre::Coordinate> coordinate_from_param(const std::string &param) {
   QString json_str = QString::fromStdString(Params().get(param));
   if (json_str.isEmpty()) return {};
 
@@ -127,7 +128,7 @@ std::optional<QMapbox::Coordinate> coordinate_from_param(const std::string &para
 
   QJsonObject json = doc.object();
   if (json["latitude"].isDouble() && json["longitude"].isDouble()) {
-    QMapbox::Coordinate coord(json["latitude"].toDouble(), json["longitude"].toDouble());
+    QMapLibre::Coordinate coord(json["latitude"].toDouble(), json["longitude"].toDouble());
     return coord;
   } else {
     return {};

selfdrive/ui/qt/maps/map_helpers.h

@@ -3,8 +3,9 @@
 #include <optional>
 #include <string>
 #include <utility>
+#include <QMapLibre/Map>
+#include <QMapLibre/Settings>
 #include <eigen3/Eigen/Dense>
-#include <QMapboxGL>
 #include <QGeoCoordinate>
 
 #include "common/params.h"
@@ -18,15 +19,15 @@ const QString MAPS_HOST = util::getenv("MAPS_HOST", MAPBOX_TOKEN.isEmpty() ? "ht
 const QString MAPS_CACHE_PATH = "/data/mbgl-cache-navd.db";
 
 QString get_mapbox_token();
-QMapboxGLSettings get_mapbox_settings();
-QGeoCoordinate to_QGeoCoordinate(const QMapbox::Coordinate &in);
-QMapbox::CoordinatesCollections model_to_collection(
+QMapLibre::Settings get_mapbox_settings();
+QGeoCoordinate to_QGeoCoordinate(const QMapLibre::Coordinate &in);
+QMapLibre::CoordinatesCollections model_to_collection(
   const cereal::LiveLocationKalman::Measurement::Reader &calibratedOrientationECEF,
   const cereal::LiveLocationKalman::Measurement::Reader &positionECEF,
   const cereal::XYZTData::Reader &line);
-QMapbox::CoordinatesCollections coordinate_to_collection(const QMapbox::Coordinate &c);
-QMapbox::CoordinatesCollections capnp_coordinate_list_to_collection(const capnp::List<cereal::NavRoute::Coordinate>::Reader &coordinate_list);
-QMapbox::CoordinatesCollections coordinate_list_to_collection(const QList<QGeoCoordinate> &coordinate_list);
+QMapLibre::CoordinatesCollections coordinate_to_collection(const QMapLibre::Coordinate &c);
+QMapLibre::CoordinatesCollections capnp_coordinate_list_to_collection(const capnp::List<cereal::NavRoute::Coordinate>::Reader &coordinate_list);
+QMapLibre::CoordinatesCollections coordinate_list_to_collection(const QList<QGeoCoordinate> &coordinate_list);
 QList<QGeoCoordinate> polyline_to_coordinate_list(const QString &polylineString);
-std::optional<QMapbox::Coordinate> coordinate_from_param(const std::string &param);
+std::optional<QMapLibre::Coordinate> coordinate_from_param(const std::string &param);
 std::pair<QString, QString> map_format_distance(float d, bool is_metric);

selfdrive/ui/qt/maps/map_panel.cc

@@ -8,7 +8,7 @@
 #include "selfdrive/ui/qt/util.h"
 #include "selfdrive/ui/ui.h"
 
-MapPanel::MapPanel(const QMapboxGLSettings &mapboxSettings, QWidget *parent) : QFrame(parent) {
+MapPanel::MapPanel(const QMapLibre::Settings &mapboxSettings, QWidget *parent) : QFrame(parent) {
   content_stack = new QStackedLayout(this);
   content_stack->setContentsMargins(0, 0, 0, 0);
 
@@ -41,8 +41,3 @@ void MapPanel::toggleMapSettings() {
   emit mapPanelRequested();
   show();
 }
-
-void MapPanel::setVisible(bool visible) {
-  QFrame::setVisible(visible);
-  uiState()->scene.map_open = visible;
-}

selfdrive/ui/qt/maps/map_panel.h

@@ -1,15 +1,14 @@
 #pragma once
 
 #include <QFrame>
-#include <QMapboxGL>
+#include <QMapLibre/Settings>
 #include <QStackedLayout>
 
 class MapPanel : public QFrame {
   Q_OBJECT
 
 public:
-  explicit MapPanel(const QMapboxGLSettings &settings, QWidget *parent = nullptr);
-  void setVisible(bool visible);
+  explicit MapPanel(const QMapLibre::Settings &settings, QWidget *parent = nullptr);
 
 signals:
   void mapPanelRequested();

selfdrive/ui/qt/maps/map_settings.cc

@@ -62,13 +62,7 @@ MapSettings::MapSettings(bool closeable, QWidget *parent) : QFrame(parent) {
       title->setStyleSheet("color: #FFFFFF; font-size: 54px; font-weight: 600;");
       heading->addWidget(title);
 
-      // NOO without Prime IP extraction
-      if (notPrime) {
-        ipAddress = QString("%1:8082").arg(wifi->getIp4Address());
-        subtitle = new QLabel(tr("Manage at %1").arg(ipAddress), this);
-      } else {
-        subtitle = new QLabel(tr("Manage at connect.comma.ai"), this);
-      }
+      subtitle = new QLabel(tr("Manage at connect.comma.ai"), this);
       subtitle->setStyleSheet("color: #A0A0A0; font-size: 40px; font-weight: 300;");
       heading->addWidget(subtitle);
     }
@@ -99,6 +93,8 @@ MapSettings::MapSettings(bool closeable, QWidget *parent) : QFrame(parent) {
 
   setStyleSheet("MapSettings { background-color: #333333; }");
   QObject::connect(NavManager::instance(), &NavManager::updated, this, &MapSettings::refresh);
+
+  wifi = new WifiManager(this);
 }
 
 void MapSettings::showEvent(QShowEvent *event) {
@@ -145,9 +141,9 @@ void MapSettings::refresh() {
 
   setUpdatesEnabled(true);
 
-  // NOO without Prime IP update
-  if (notPrime) {
-    ipAddress = QString("%1:8082").arg(wifi->getIp4Address());
+  // Use IP for NOO without Prime
+  if (!uiState()->hasPrime()) {
+    QString ipAddress = QString("%1:8082").arg(wifi->getIp4Address());
     subtitle->setText(tr("Manage at %1").arg(ipAddress));
   }
 }

selfdrive/ui/qt/maps/map_settings.h

@@ -66,10 +66,9 @@ private:
   std::vector<DestinationWidget *> widgets;
 
   // FrogPilot variables
-  bool notPrime = Params().getInt("PrimeType") == 0;
   QLabel *subtitle;
-  QString ipAddress;
-  WifiManager *wifi = new WifiManager(this);
+
+  WifiManager *wifi;
 
 signals:
   void closeSettings();