Custom App Extension

~/.config/HPR/extensions/main.lua

%APPDATA%\HPR\HPR_Config\extensions\main.lua

function onTick(delta)
    local activeWindow = HPR.getCurrentWindow_E()
    local activeTitle  = HPR.getCurrentTitle_E()

    -- Make sure both values exist before using them
    local isWindowValid   = activeWindow and activeTitle
    local isSpotifyActive = isWindowValid and
        string.find(string.lower(activeWindow), "spotify")

    if isSpotifyActive then
        print("Spotify is active! Title: " .. activeTitle)
    end
end

local function parseSpotifyTitle(windowTitle)
    -- Look for the " - " separator that Spotify uses
    local hyphen_start, hyphen_end = string.find(windowTitle, " %- ")

    if not hyphen_start then
        return nil, nil  -- Title doesn't match "Artist - Song" format
    end

    -- Split the string and trim whitespace from both parts
    local artistName = string.sub(windowTitle, 1, hyphen_start - 1):match("^%s*(.-)%s*$")
    local songName   = string.sub(windowTitle, hyphen_end + 1):match("^%s*(.-)%s*$")

    return songName, artistName
end

-- Module-level state: persists across ticks for the extension's lifetime
local spotify_history = {}
local time_since_last_flush = 0

function onTick(delta)
    local activeWindow = HPR.getCurrentWindow_E()
    local activeTitle  = HPR.getCurrentTitle_E()

    local isWindowValid   = activeWindow and activeTitle
    local isSpotifyActive = isWindowValid and
        string.find(string.lower(activeWindow), "spotify")

    if isSpotifyActive then
        local songName, artistName = parseSpotifyTitle(activeTitle)

        if songName and artistName then
            -- Create a new entry if this is the first time we've seen this song
            if not spotify_history[songName] then
                spotify_history[songName] = { artist = artistName, play_time = 0 }
            end

            -- Accumulate: add the actual elapsed time (delta) to the song's total
            spotify_history[songName].play_time = spotify_history[songName].play_time + delta
        end
    end
end

function init()
    -- ... database setup code from Step 5 ...

    print("[Spotify Extension] Initialized successfully.")
    return 150 -- Tick every 150 milliseconds
end

-- Inside onTick(delta), after the detection and caching logic:

-- Format and sort the track list for the UI
local formattedSongs = {}
local totalPlayTime = 0

for songName, songData in pairs(spotify_history) do
    totalPlayTime = totalPlayTime + songData.play_time
    table.insert(formattedSongs, {
        name       = songName,
        artist     = songData.artist,
        duration   = HPR.formatTime_HHMMSS_E(math.floor(songData.play_time)),
        duration_i = math.floor(songData.play_time)
    })
end

-- Sort descending so the most-played song is at the top
table.sort(formattedSongs, function(songA, songB)
    return songA.duration_i > songB.duration_i
end)

-- Push to the Slint UI
HPR.setUiProperty_E("spotifySongs_S", formattedSongs)
HPR.setUiProperty_E("trackedTime_Spotify_S", math.floor(totalPlayTime))

function onExit()
    -- Force a final database save to persist today's listening time
    flushToDatabase()
    
    -- Clean up event subscriptions to prevent memory leaks
    HPR.disconnect_E("MIDNIGHT_ROLLOVER", midnightId)
    HPR.disconnect_E("LOAD_DATABASE_SINGULAR", pastDbId)
    HPR.disconnect_E("LOAD_LIVE_DATA", liveDbId)
end

local spotify_history = {}          -- Live daily data
local past_spotify_history = {}     -- Loaded historical data
local is_showing_historical = false -- View state toggler
local time_since_last_flush = 0

local midnightId = 0
local pastDbId = 0
local liveDbId = 0

-- Parse: "Artist - Song" -> songName, artistName
local function parseSpotifyTitle(windowTitle)
    local hyphen_start, hyphen_end = string.find(windowTitle, " %- ")
    if not hyphen_start then
        return nil, nil
    end
    local artistName = string.sub(windowTitle, 1, hyphen_start - 1):match("^%s*(.-)%s*$")
    local songName   = string.sub(windowTitle, hyphen_end + 1):match("^%s*(.-)%s*$")
    return songName, artistName
end

function flushToDatabase()
    for songName, songData in pairs(spotify_history) do
        HPR.dbExecute_E(
            "insert or replace into spotify_songs (song_name, artist_name, play_duration_ms) values (?, ?, ?);",
            { songName, songData.artist, tostring(math.floor(songData.play_time)) }
        )
    end
end

function init()
    HPR.authorName    = "Plexescor"
    HPR.extensionName = "Spotify Watcher HPR Extension"

    -- Initialize database table
    HPR.dbExecute_E([[
        create table if not exists spotify_songs (
            song_name text unique,
            artist_name text,
            play_duration_ms int
        );
    ]])

    -- Load today's live songs on startup
    local dbRows = HPR.dbQuery_E("select song_name, artist_name, play_duration_ms from spotify_songs;")
    for rowIndex, row in ipairs(dbRows) do
        spotify_history[row.song_name] = {
            artist    = row.artist_name,
            play_time = tonumber(row.play_duration_ms) or 0
        }
    end

    -- Clock strikes midnight
    midnightId = HPR.connect_E("MIDNIGHT_ROLLOVER", function(data)
        spotify_history = {}
    end)

    -- Historical db loaded
    pastDbId = HPR.connect_E("LOAD_DATABASE_SINGULAR", function(data)
        local success, histRows = pcall(HPR.dbQueryHistorical_E, "SELECT song_name, artist_name, play_duration_ms FROM spotify_songs;")

        if success and histRows and #histRows > 0 then
            past_spotify_history = {}
            for _, row in ipairs(histRows) do
                past_spotify_history[row.song_name] = {
                    artist    = row.artist_name,
                    play_time = tonumber(row.play_duration_ms) or 0
                }
            end
            is_showing_historical = true
        else
            -- Fall back if empty
            past_spotify_history = {}
            is_showing_historical = false
        end
    end)

    -- Back to live view
    liveDbId = HPR.connect_E("LOAD_LIVE_DATA", function(data)
        is_showing_historical = false
    end)

    print("[Spotify Extension] Loaded successfully.")
    return 150 -- Tick rate
end

function onTick(delta)
    -- Always track active live songs in background
    local activeWindow = HPR.getCurrentWindow_E()
    local activeTitle  = HPR.getCurrentTitle_E()
    local isWindowValid   = activeWindow and activeTitle
    
    local isSpotifyActive = isWindowValid and string.find(string.lower(activeWindow), "spotify")
    if isSpotifyActive then
        local songName, artistName = parseSpotifyTitle(activeTitle)
        if songName and artistName then
            if not spotify_history[songName] then
                spotify_history[songName] = { artist = artistName, play_time = 0 }
            end
            spotify_history[songName].play_time = spotify_history[songName].play_time + delta
        end
    end

    -- Select active data source
    local active_source = is_showing_historical and past_spotify_history or spotify_history

    -- Format and send list to Slint UI
    local formattedSongs = {}
    local totalPlayTime = 0
    for songName, songData in pairs(active_source) do
        totalPlayTime = totalPlayTime + songData.play_time
        table.insert(formattedSongs, {
            name       = songName,
            artist     = songData.artist,
            duration   = HPR.formatTime_HHMMSS_E(math.floor(songData.play_time)),
            duration_i = math.floor(songData.play_time)
        })
    end
    
    table.sort(formattedSongs, function(songA, songB)
        return songA.duration_i > songB.duration_i
    end)

    HPR.setUiProperty_E("spotifySongs_S", formattedSongs)
    HPR.setUiProperty_E("trackedTime_Spotify_S", math.floor(totalPlayTime))

    -- Save to local db every 10s
    time_since_last_flush = time_since_last_flush + delta
    if time_since_last_flush >= 10000 then
        pcall(flushToDatabase)
        time_since_last_flush = 0
    end
end

function flushToDatabase()
    for songName, songData in pairs(spotify_history) do
        HPR.dbExecute_E(
            "insert or replace into spotify_songs (song_name, artist_name, play_duration_ms) values (?, ?, ?);",
            { songName, songData.artist, tostring(math.floor(songData.play_time)) }
        )
    end
end