Update code docs

Author: jellyrock-bot

docs/components_config_JRServer.bs.html

@@ -27,7 +27,14 @@
 
   m.poster.uri = serverItem.iconUrl
   m.name.text = serverItem.name
-  m.baseUrl.text = serverItem.baseUrl
+  ' Prefer originalUrl (user-entered or scheme-stripped) over the canonical baseUrl.
+  ' Falls back to baseUrl for SSDP-discovered servers with no saved entry and for
+  ' old saved_servers entries that predate this field.
+  displayUrl = serverItem.originalUrl
+  if not isValidAndNotEmpty(displayUrl)
+    displayUrl = serverItem.baseUrl
+  end if
+  m.baseUrl.text = displayUrl
 end sub
 
 sub onFocusPercentChange()

docs/components_config_ServerDiscoveryTask.bs.html

@@ -41,10 +41,81 @@
 
   end while
 
+  FetchServerIds()
   m.top.content = m.servers
   m.log.debug("Jellyfin servers found", m.servers[0], m.servers[1], m.servers[2])
 end sub
 
+' Fetch server IDs and names from /system/info/public for all discovered servers.
+' All requests are fired in parallel on a shared port and collected within a 5s budget.
+' Also strips the URL scheme to produce originalUrl (e.g. "192.168.1.100:8096") so:
+'   - users see clean URLs in the server picker (no "http://" prefix)
+'   - inferServerUrl() can re-probe the correct protocol on each connection,
+'     automatically picking up HTTPS if the server has been upgraded since last save
+sub FetchServerIds()
+  if m.servers.Count() = 0 then return
+
+  port = CreateObject("roMessagePort")
+  identityToIndex = {}
+  transfers = [] ' hold refs — roUrlTransfer is GC'd if not kept in scope
+
+  for i = 0 to m.servers.Count() - 1
+    serverUrl = m.servers[i].baseUrl
+    if not isValidAndNotEmpty(serverUrl) then continue for
+
+    http = CreateObject("roUrlTransfer")
+    http.SetUrl(serverUrl + "/system/info/public")
+    http.SetMessagePort(port)
+    if serverUrl.Left(8) = "https://"
+      http.SetCertificatesFile("common:/certs/ca-bundle.crt")
+    end if
+    http.AsyncGetToString()
+    identityToIndex[http.GetIdentity().ToStr()] = i
+    transfers.push(http)
+  end for
+
+  remaining = transfers.Count()
+  ts = CreateObject("roTimespan")
+
+  while remaining > 0 and ts.TotalMilliseconds() < 5000
+    resp = wait(500, port)
+    if type(resp) = "roUrlEvent"
+      idx = identityToIndex[resp.GetSourceIdentity().ToStr()]
+      if isValid(idx) and resp.GetResponseCode() = 200
+        info = ParseJson(resp.GetString())
+        if isValid(info)
+          if isValidAndNotEmpty(info.Id)
+            m.servers[idx].id = info.Id
+          end if
+          if isValidAndNotEmpty(info.ServerName)
+            m.servers[idx].name = info.ServerName
+          end if
+        end if
+      end if
+      remaining--
+    end if
+  end while
+
+  ' Strip URL scheme from every discovered server to produce a clean originalUrl.
+  ' inferServerUrl() probes http/https candidates in parallel so there is no reconnect
+  ' penalty for servers that are HTTP-only.
+  for i = 0 to m.servers.Count() - 1
+    serverUrl = m.servers[i].baseUrl
+    if not isValidAndNotEmpty(serverUrl) then continue for
+
+    schemeEnd = Instr(1, serverUrl, "://")
+    if schemeEnd > 0
+      originalUrl = Mid(serverUrl, schemeEnd + 3)
+    else
+      originalUrl = serverUrl
+    end if
+    if Right(originalUrl, 1) = "/" and Len(originalUrl) > 1
+      originalUrl = Left(originalUrl, Len(originalUrl) - 1)
+    end if
+    m.servers[i].originalUrl = originalUrl
+  end for
+end sub
+
 sub AddServer(serverItem)
   if not isValid(m.serverUrlMap[serverItem.baseUrl])
     m.serverUrlMap[serverItem.baseUrl] = true

docs/components_config_SetServerScreen.bs.html

@@ -35,30 +35,65 @@
 
   items = CreateObject("roSGNode", "ContentNode")
   stopLoadingSpinner()
+
+  ' Load saved servers upfront — used in both passes below
+  savedServers = { serverList: [] }
+  saved = get_setting("saved_servers")
+  if isValid(saved)
+    parsed = ParseJson(saved)
+    if isValid(parsed) and isValid(parsed.serverList)
+      savedServers = parsed
+    end if
+  end if
+
+  ' Pass 1: Add all SSDP-discovered servers.
+  ' If a matching saved entry exists, inject its originalUrl so the user sees their own
+  ' URL (e.g. "192.168.1.100:8096" or an HTTPS address) instead of the raw SSDP URL.
+  ' Dedup uses id first (robust to URL changes), then falls back to canonical baseUrl
+  ' for backward compatibility with saved entries that predate this change.
   for each serverItem in m.servers
     serverItem.subtype = "ContentNode"
-    'add new fields for every server property onto the ContentNode (rather than making a dedicated component just to hold data...)
+    for each savedServer in savedServers.serverList
+      isMatch = false
+      if isValidAndNotEmpty(serverItem.id) and isValidAndNotEmpty(savedServer.id)
+        isMatch = (serverItem.id = savedServer.id)
+      else if LCase(serverItem.baseUrl) = savedServer.baseUrl
+        isMatch = true
+      end if
+      if isMatch
+        ' Merge: keep SSDP name and connection URL, restore saved originalUrl
+        savedOriginalUrl = savedServer.originalUrl
+        if not isValidAndNotEmpty(savedOriginalUrl)
+          savedOriginalUrl = savedServer.baseUrl ' backward compat: old entries have no originalUrl
+        end if
+        serverItem.originalUrl = savedOriginalUrl
+        serverItem.isSaved = true ' mark as deletable — this server exists in saved_servers
+        exit for
+      end if
+    end for
     items.update([serverItem], true)
   end for
 
-  'load any previously logged in to servers as well (if they aren't already discovered on the local network)
-  saved = get_setting("saved_servers")
-  if isValid(saved)
-    savedServers = ParseJson(saved)
-    for each savedServer in savedServers.serverList
-      alreadyListed = false
-      for each listed in m.servers
-        if LCase(listed.baseUrl) = savedServer.baseUrl 'saved server data is always lowercase
+  ' Pass 2: Add saved servers not found by SSDP (e.g. remote servers)
+  for each savedServer in savedServers.serverList
+    alreadyListed = false
+    for each listed in m.servers
+      if isValidAndNotEmpty(listed.id) and isValidAndNotEmpty(savedServer.id)
+        if listed.id = savedServer.id
           alreadyListed = true
           exit for
         end if
-      end for
-      if alreadyListed = false
-        items.update([savedServer], true)
-        m.servers.push(savedServer)
+      else if LCase(listed.baseUrl) = savedServer.baseUrl
+        alreadyListed = true
+        exit for
       end if
     end for
-  end if
+    if not alreadyListed
+      savedServer.isSaved = true ' mark as deletable — this server exists in saved_servers
+      items.update([savedServer], true)
+      m.servers.push(savedServer)
+    end if
+  end for
 
   m.serverPicker.content = items
 
@@ -130,7 +165,14 @@
   handled = true
 
   if key = "OK" and m.serverPicker.hasFocus()
-    m.top.serverUrl = m.serverPicker.content.getChild(m.serverPicker.itemFocused).baseUrl
+    item = m.serverPicker.content.getChild(m.serverPicker.itemFocused)
+    ' Prefer originalUrl (user-entered or scheme-stripped SSDP URL) so inferServerUrl()
+    ' can re-discover the correct protocol rather than locking in the canonical form
+    selectedUrl = item.originalUrl
+    if not isValidAndNotEmpty(selectedUrl)
+      selectedUrl = item.baseUrl
+    end if
+    m.top.serverUrl = selectedUrl
     m.buttons.setFocus(true)
     'if the user pressed the down key and we are already at the last child of server picker, then change focus to the url textbox
   else if key = "down" and m.serverPicker.hasFocus() and m.serverPicker.content.getChildCount() > 0 and m.serverPicker.itemFocused = m.serverPicker.content.getChildCount() - 1
@@ -161,10 +203,10 @@
     m.buttons.setFocus(true)
   else if key = "options"
     if m.serverPicker.itemFocused >= 0 and m.serverPicker.itemFocused < m.serverPicker.content.getChildCount()
-      serverName = m.serverPicker.content.getChild(m.serverPicker.itemFocused).name
-      if m.servers.Count() > 0 and Instr(1, serverName, "Saved") > 0
+      item = m.serverPicker.content.getChild(m.serverPicker.itemFocused)
+      if m.servers.Count() > 0 and item.isSaved = true
         'Can only delete previously saved servers, not locally discovered ones
-        'So if we are on a "Saved" item, let the options dialog be shown (handled elsewhere)
+        'So if we are on a saved item, let the options dialog be shown (handled elsewhere)
         handled = false
       end if
     end if

docs/data/search.json

@@ -229,53 +229,92 @@
 end function
 
 sub SaveServerList()
-  'Save off this server to our list of saved servers for easier navigation between servers
-  serverUrl = m.global.server.serverUrl
-  saved = get_setting("saved_servers")
+  ' Save this server to the list of previously-used servers shown in the server picker.
+  ' baseUrl: canonical URL (lowercase) — used for deduplication against SSDP-discovered servers.
+  ' originalUrl: user-entered URL from registry — shown in the picker and pre-filled on re-selection,
+  '              so inferServerUrl() can re-discover the correct protocol on each connection.
+  ' id: Jellyfin server ID — primary deduplication key, robust to URL changes (e.g. HTTP→HTTPS).
+  globalServer = m.global.server
+  serverUrl = globalServer.serverUrl
+  serverId = globalServer.id
+  serverName = globalServer.name
+  originalUrl = get_setting("server") ' set correctly by server.UpdateURL() before this is called
+
   if isValid(serverUrl)
-    serverUrl = LCase(serverUrl)'Saved server data is always lowercase
+    serverUrl = LCase(serverUrl) ' canonical URL always lowercase for comparison
   end if
-  entryCount = 0
-  addNewEntry = true
+  if not isValidAndNotEmpty(originalUrl)
+    originalUrl = serverUrl ' fallback: use canonical if original is somehow missing
+  end if
+
   savedServers = { serverList: [] }
+  saved = get_setting("saved_servers")
   if isValid(saved)
-    savedServers = ParseJson(saved)
-    entryCount = savedServers.serverList.Count()
-    if isValid(savedServers.serverList) and entryCount > 0
-      for each item in savedServers.serverList
-        if item.baseUrl = serverUrl
-          addNewEntry = false
-          exit for
-        end if
-      end for
+    parsed = ParseJson(saved)
+    if isValid(parsed) and isValid(parsed.serverList)
+      savedServers = parsed
     end if
   end if
 
-  if addNewEntry
-    if entryCount = 0
-      set_setting("saved_servers", FormatJson({ serverList: [{ name: m.serverSelection, baseUrl: serverUrl, iconUrl: "pkg:/images/branding/logo-icon120.jpg", iconWidth: 120, iconHeight: 120 }] }))
-    else
-      savedServers.serverList.Push({ name: m.serverSelection, baseUrl: serverUrl, iconUrl: "pkg:/images/branding/logo-icon120.jpg", iconWidth: 120, iconHeight: 120 })
+  ' Check for an existing entry (ID-based first; URL fallback for old entries without id)
+  for i = 0 to savedServers.serverList.Count() - 1
+    item = savedServers.serverList[i]
+    isMatch = false
+    if isValidAndNotEmpty(serverId) and isValidAndNotEmpty(item.id)
+      isMatch = (item.id = serverId)
+    else if LCase(item.baseUrl) = serverUrl
+      isMatch = true
+    end if
+
+    if isMatch
+      ' Update in-place: refresh mutable server identity fields (name, id, baseUrl, originalUrl).
+      ' iconUrl/iconWidth/iconHeight are static app branding defaults and are not changed.
+      savedServers.serverList[i].name = serverName
+      savedServers.serverList[i].id = serverId
+      savedServers.serverList[i].baseUrl = serverUrl ' keep canonical URL current (e.g. HTTP→HTTPS)
+      savedServers.serverList[i].originalUrl = originalUrl
       set_setting("saved_servers", FormatJson(savedServers))
+      return
     end if
-  end if
+  end for
+
+  ' No existing entry found — append a new one
+  savedServers.serverList.Push({
+    name: serverName,
+    id: serverId,
+    baseUrl: serverUrl,
+    originalUrl: originalUrl,
+    iconUrl: "pkg:/images/branding/logo-icon120.jpg",
+    iconWidth: 120,
+    iconHeight: 120
+  })
+  set_setting("saved_servers", FormatJson(savedServers))
 end sub
 
-sub DeleteFromServerList(urlToDelete)
+sub DeleteFromServerList(idOrUrl as string)
+  ' idOrUrl should be the server's id when available (passed from itemToDelete.id).
+  ' Falls back to a canonical baseUrl for legacy entries that predate the id field.
+  ' ID match is tried first so deletion is correct even when the saved entry's baseUrl
+  ' differs from the picker item's baseUrl (e.g. a saved HTTPS entry matched via SSDP
+  ' on HTTP — the picker item carries the SSDP baseUrl, not the saved one).
   saved = get_setting("saved_servers")
-  if isValid(urlToDelete)
-    urlToDelete = LCase(urlToDelete)
-  end if
-  if isValid(saved)
-    savedServers = ParseJson(saved)
-    newServers = { serverList: [] }
-    for each item in savedServers.serverList
-      if item.baseUrl <> urlToDelete
-        newServers.serverList.Push(item)
-      end if
-    end for
-    set_setting("saved_servers", FormatJson(newServers))
-  end if
+  if not isValid(saved) then return
+
+  savedServers = ParseJson(saved)
+  newServers = { serverList: [] }
+  normalizedInput = LCase(idOrUrl) ' for URL fallback comparison (baseUrls are always lowercase)
+  for each item in savedServers.serverList
+    keepEntry = true
+    if isValidAndNotEmpty(item.id) and item.id = idOrUrl
+      keepEntry = false ' ID match — remove this entry
+    else if item.baseUrl = normalizedInput
+      keepEntry = false ' URL fallback — remove this entry
+    end if
+    if keepEntry
+      newServers.serverList.Push(item)
+    end if
+  end for
+  set_setting("saved_servers", FormatJson(newServers))
 end sub
 
 ' Roku Performance monitoring
@@ -377,9 +416,14 @@
       else if nodeName = "delete_saved"
         serverPicker = screen.findNode("serverPicker")
         itemToDelete = serverPicker.content.getChild(serverPicker.itemFocused)
-        urlToDelete = itemToDelete.baseUrl
-        if isValid(urlToDelete)
-          DeleteFromServerList(urlToDelete)
+        ' Prefer id for deletion — robust when the picker item's baseUrl differs from
+        ' the saved entry's baseUrl (e.g. SSDP HTTP item merged from an HTTPS saved entry)
+        idOrUrl = itemToDelete.id
+        if not isValidAndNotEmpty(idOrUrl)
+          idOrUrl = itemToDelete.baseUrl
+        end if
+        if isValidAndNotEmpty(idOrUrl)
+          DeleteFromServerList(idOrUrl)
           serverPicker.content.removeChild(itemToDelete)
           sidepanel.visible = false
           serverPicker.setFocus(true)