Add config info to Diagnostics view; switch SpotifyArduino to use lateInit() with a global instance

Author: Electric-Diversions

platformio.ini

@@ -12,7 +12,7 @@
 platform = espressif32@~6.10.0
 ; esp-wrover-kit is 4MB ESP32-WROVER-B compatible.  	
 board = esp-wrover-kit
-; custom_esp-wrover-kit to enable 8MB PSRAM and a larger heap.
+; custom_esp-wrover-kit to enable 8MB PSRAM
 ;board = custom_esp-wrover-kit
 framework = arduino
 monitor_speed = 115200

src/SpotifyArtMgr.cpp

@@ -694,6 +694,20 @@ void SpotifyArtMgr::determineCacheSize()
     }
 }
 
+/*
+** ===================================================================
+** getMaxCacheSize()
+**    Returns the current maximum cache size used for album art.
+**
+** Returns:
+**    size_t - The maximum number of cached album art entries.
+** ===================================================================
+*/
+size_t SpotifyArtMgr::getMaxCacheSize()
+{
+    return _maxCacheSize;
+}
+
 /*
 ** ===================================================================
 ** loadCacheIndex()

src/SpotifyArtMgr.h

@@ -76,6 +76,7 @@ class SpotifyArtMgr
     static SpotifyArtMgr* getInstance();
 
     void        setMaxCacheSize(size_t maxSize);
+    size_t      getMaxCacheSize();
     void        saveCacheIndex();
     bool        isCacheDirty();
 

src/SpotifyPlayer.cpp

@@ -83,11 +83,8 @@ void SpotifyPlayer::initialize(QueueHandle_t    *pScuiQueue)
     _spotifyClientId     = Vault::getInstance().getSpotifyClientID();
     _spotifyClientSecret = Vault::getInstance().getSpotifyClientSecret();
 
-   _pSpotify = new SpotifyArduino(
-        client,
-        _spotifyClientId.c_str(),
-        _spotifyClientSecret.c_str()
-    );    
+    spotify.lateInit(_spotifyClientId.c_str(), _spotifyClientSecret.c_str(), _spotifyRefreshToken.c_str());
+
     // client is defined in ThingPulse/spotify.h
     client.setCACert(spotify_server_cert);  
 
@@ -168,7 +165,7 @@ bool SpotifyPlayer::requestRefreshToken()
     spLogI(LOGTAG_PLAYER, "Requesting Spotify refresh token through the browser via auth code.");
 
     String spotifyAuthCode = fetchSpotifyAuthCode();
-    _spotifyRefreshToken = _pSpotify->requestAccessTokens(spotifyAuthCode.c_str(), SPOTIFY_REDIRECT_URI);
+    _spotifyRefreshToken = spotify.requestAccessTokens(spotifyAuthCode.c_str(), SPOTIFY_REDIRECT_URI);
     SCFileIO::getInstance().saveFsString(SPOTIFY_REFRESH_TOKEN_FILE_NAME, _spotifyRefreshToken);
 
     return true;
@@ -196,8 +193,8 @@ void SpotifyPlayer::login()
     // - keeps track of the refresh token and its TTL internally
     // - automatically renews the actual access token using the refresh token
     // -> see SpotifyArduino.h#autoTokenRefresh and SpotifyArduino::checkAndRefreshAccessToken() (called before every API function)
-    _pSpotify->setRefreshToken(_spotifyRefreshToken.c_str());
-    _pSpotify->refreshAccessToken();
+    spotify.setRefreshToken(_spotifyRefreshToken.c_str());
+    spotify.refreshAccessToken();
     spLogI(LOGTAG_PLAYER, "Authentication against Spotify done. Refresh token: %s", _spotifyRefreshToken.c_str());    
 }
 
@@ -251,7 +248,7 @@ void SpotifyPlayer::nextSong()
                     static_cast<int>(TFTColor::SC_NetworkInProgress));
     if (xSemaphoreTake(_xSemaphoreNetwork, portMAX_DELAY)) 
     {
-        if (_pSpotify->nextTrack())
+        if (spotify.nextTrack())
         {
             postScuiMessage(SCUIMessageType::UM_STATUS_BOX,
                             "",
@@ -291,7 +288,7 @@ void SpotifyPlayer::previousSong()
 
     if (xSemaphoreTake(_xSemaphoreNetwork, portMAX_DELAY)) 
     {
-        if (_pSpotify->previousTrack())
+        if (spotify.previousTrack())
         {
             postScuiMessage(SCUIMessageType::UM_STATUS_BOX,
                             "",
@@ -333,7 +330,7 @@ void SpotifyPlayer::pauseSong()
             postScuiMessage(SCUIMessageType::UM_STATUS_BOX,
                             "Making Call",
                             static_cast<int>(TFTColor::SC_NetworkInProgress));    
-            if (_pSpotify->pause())
+            if (spotify.pause())
             {
                 postScuiMessage(SCUIMessageType::UM_STATUS_BOX,
                                 "",
@@ -353,7 +350,7 @@ void SpotifyPlayer::pauseSong()
             postScuiMessage(SCUIMessageType::UM_STATUS_BOX,
                             "Making Call",
                             static_cast<int>(TFTColor::SC_NetworkInProgress));    
-            if (_pSpotify->play())
+            if (spotify.play())
             {
                 postScuiMessage(SCUIMessageType::UM_STATUS_BOX,
                                 "",
@@ -399,7 +396,7 @@ void SpotifyPlayer::refreshCurrentTrack()
         {
             spLogI(LOGTAG_MULTITASK, "Invoking spotify.getCurrentlyPlaying(...)");
             Monitor::start(MONITOR_ID_SPOTIFY_GET_CURRENTLY_PLAYING, LOGTAG_METRICS, "spotify.getCurrentlyPlaying(...)");
-            status = _pSpotify->getCurrentlyPlaying(SpotifyPlayer::getCurrentlyPlayingCallback, SP_SPOTIFY_MARKET);
+            status = spotify.getCurrentlyPlaying(SpotifyPlayer::getCurrentlyPlayingCallback, SP_SPOTIFY_MARKET);
             Monitor::stop(MONITOR_ID_SPOTIFY_GET_CURRENTLY_PLAYING);
             xSemaphoreGive(_xSemaphoreNetwork);
         }

src/SpotifyPlayer.h

@@ -20,9 +20,6 @@
 #include "DisplayUI.h"
 #include "PlayingMetadata.h"
 #include "scui.h"
-
-// Forward declaration to avoid including full spotify.h in the header
-class SpotifyArduino;
 class SpotifyPlayer {
 public:
     // Public method to access the singleton instance
@@ -53,7 +50,6 @@ class SpotifyPlayer {
 private:
     // Member variables
     String              _spotifyRefreshToken   = "";
-    // DisplayUI           *_pUI;
     QueueHandle_t       *_pScuiQueue; 
     String              _currentTrackUri       = "";        // Tracks the currently playing song
     bool                _isPlaying             = false;
@@ -66,7 +62,6 @@ class SpotifyPlayer {
     SemaphoreHandle_t   _xSemaphoreNetwork     = xSemaphoreCreateMutex();
     SemaphoreHandle_t   _xSemaphoreDataCopy    = xSemaphoreCreateMutex();
     TaskHandle_t        _refreshTaskHandle;
-    SpotifyArduino      *_pSpotify             = nullptr;
     String              _spotifyClientId;
     String              _spotifyClientSecret;
 

src/ThingPulse/spotify.h

@@ -22,7 +22,6 @@
 #include <ArduinoJson.h>
 #include <ESPmDNS.h>
 #include <SpotifyArduino.h>
-// #include <SpotifyArduinoCert.h>
 #include <WebServer.h>
 #include <WiFi.h>
 #include <WiFiClient.h>
@@ -53,6 +52,13 @@ String scope    = "user-read-playback-state%20user-modify-playback-state";
 WebServer server(80);
 WiFiClientSecure client;
 
+// Note: SpotifyArduino does not initialize its _refreshToken pointer.
+// When declared as a global, this works because globals are zero-initialized by default,
+// making _refreshToken safely nullptr. If the instance is created dynamically or locally,
+// this assumption can lead to heap corruption when delete is called on an uninitialized
+// _refreshToken in setRefreshToken().
+SpotifyArduino spotify(client);
+
 const char *webpageTemplate =
     R"(
 <!DOCTYPE html>
@@ -130,8 +136,6 @@ String fetchSpotifyAuthCode() {
     log_i("Open browser at http://%s.local", SPOTIFY_ESPOTIFIER_NODE_NAME);
   }
 
-  //printRootWebpage();
-
   server.on("/", handleRoot);
   server.on("/callback/", handleCallback);
   server.on("/favicon.ico", handleFavicon);

src/UIViews/DiagnosticsView.cpp

@@ -24,6 +24,8 @@
 #include "settings.h"
 #include "Renderers/BackButtonRenderer.h"
 #include "esp_heap_caps.h"
+#include "Vault.h"
+#include "SpotifyArtMgr.h"
 
 /*
 ** ===================================================================
@@ -119,8 +121,15 @@ void DiagnosticsView::clearAndPaintScreen(PlayingMetadata playing)
     // **** Track Progress Header *****=
     _pUI->lDrawString("progressMs / durationMs :: lastRefreshMs (Pct)", 10, rowToY(4), fontSize, TFTColor::DarkGreen, TFTColor::Black,"");
 
-    // **** Compile / Version Information *****
-    std::string versionStr = std::string("Version: ") + VERSION;
+    // **** Compile / Version / Config Information *****
+    char buffer[40];
+    snprintf(buffer, sizeof(buffer), "Config: %c %c %d",
+             toString(Vault::getInstance().getCredentialSource())[0],
+             toString(Vault::getInstance().getPrivacyLevel())[0],
+             SpotifyArtMgr::getInstance()->getMaxCacheSize());    
+    std::string configInfo = std::string(buffer);
+
+    std::string versionStr = std::string("Version: ") + VERSION + " - " + configInfo;
     _pUI->lDrawString(versionStr.c_str(), 90, rowToY(12), fontSize, TFTColor::DarkGrey, TFTColor::Black,"#### ################## ####");
     versionStr = std::string("Compile: ") + COMPILE_TIME; 
     _pUI->lDrawString(versionStr.c_str(), 90, rowToY(13), fontSize, TFTColor::DarkGrey, TFTColor::Black,"#### ################## ####");

src/Vault.cpp

@@ -57,6 +57,25 @@ const char* toString(VaultPrivacyLevel level)
     }
 }
 
+/*
+** ===================================================================
+** toString(CredentialSource)
+**
+**    Converts a CredentialSource enum value to its corresponding
+**    string representation for logging, diagnostics, and debugging.
+** ===================================================================
+*/
+const char* toString(CredentialSource source)
+{
+    switch (source)
+    {
+        case CredentialSource::Hardcoded: return "Hardcoded";
+        case CredentialSource::INIFile:   return "INIFile";
+        default:                          return "Unknown";
+    }
+}
+
+
 /*
 ** ===================================================================
 ** getInstance()
@@ -265,6 +284,23 @@ VaultPrivacyLevel Vault::getPrivacyLevel()
     return _privacyLevel;
 }
 
+/*
+** ===================================================================
+** getCredentialSource()
+**
+**    Returns the current source of credentials in use.
+**    If _useHardcodedValues is true, credentials are coming from
+**    settings.h; otherwise, they are sourced from user.ini.
+**
+** Returns:
+**    CredentialSource enum value indicating the source.
+** ===================================================================
+*/
+CredentialSource Vault::getCredentialSource()
+{
+    return _useHardcodedValues ? CredentialSource::Hardcoded : CredentialSource::INIFile;
+}
+
 /*
 ** ===================================================================
 ** getSSID()

src/Vault.h

@@ -51,6 +51,16 @@ enum class VaultPrivacyLevel
     Better  // Use AES-encrypted credentials; tied to device MAC address, non-reusable
 };
 
+// Defines credential source
+enum class CredentialSource
+{
+    Hardcoded,   // Plaintext hardcoded values
+    INIFile,     // Loaded values from the ini file
+};
+
+const char* toString(VaultPrivacyLevel level);
+const char* toString(CredentialSource source);
+
 // Vault definition
 class Vault
 {
@@ -59,6 +69,8 @@ class Vault
 
     void              setPrivacyLevel(VaultPrivacyLevel level);
     VaultPrivacyLevel getPrivacyLevel();
+    CredentialSource  getCredentialSource();
+
     void              initialize();
     void              eraseEncryptedCredentials();