fix: real episode duration for progress bar, paragraph-aware show notes

The Continue Listening bar divided by a hardcoded 1800s, so every episode
was treated as 30 minutes long and anything past that read as complete.
Duration is now cached per guid from AVPlayer, falling back to
itunes:duration; no bar is drawn when the length is genuinely unknown.

Show notes carry their structure only in <p>/<br>/<li>, which stripHTML
discarded along with the inline tags, fusing everything into one block.
Block-level tags now map to line breaks and numeric entities are decoded.

Also fixes a FeedParser case where a multi-pattern 'where' clause only
guarded the last pattern, letting <content> clobber a parsed summary.

Author: srv-admin

build/podcold_ios6.ipa

@@ -17,6 +17,39 @@ class Episode: NSObject {
         UserDefaults.standard.set(seconds, forKey: "pos_\(guid)")
     }
 
+    // MARK: - Duration
+    // Feeds are inconsistent: itunes:duration may be plain seconds ("3600"),
+    // "MM:SS" or "HH:MM:SS", and plenty of feeds omit it entirely. The real
+    // length is only known once AVPlayer has loaded the asset, so it is cached
+    // per guid the first time playback reports it.
+
+    func savedDuration() -> Double {
+        return UserDefaults.standard.double(forKey: "dur_\(guid)")
+    }
+
+    func saveDuration(_ seconds: Double) {
+        // Written from the 1-s time observer — only touch UserDefaults on change
+        guard seconds > 0, abs(savedDuration() - seconds) > 1 else { return }
+        UserDefaults.standard.set(seconds, forKey: "dur_\(guid)")
+    }
+
+    // Best known total length in seconds; 0 when unknown.
+    func totalDuration() -> Double {
+        let cached = savedDuration()
+        return cached > 0 ? cached : Episode.parseDuration(duration)
+    }
+
+    static func parseDuration(_ s: String) -> Double {
+        let t = s.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !t.isEmpty else { return 0 }
+        var total: Double = 0
+        for part in t.components(separatedBy: ":") {
+            guard let v = Double(part) else { return 0 }
+            total = total * 60 + v
+        }
+        return total
+    }
+
     // MARK: - Played tracking
     // savedPosition() alone cannot distinguish "never started" from "marked done"
     // (both are 0), so completed episodes are tracked separately by guid.

podcold/podcold/Models/Episode.swift

@@ -160,12 +160,10 @@ class FeedParser: NSObject, XMLParserDelegate {
             if currentEpisode?.pubDate.isEmpty == true { currentEpisode?.pubDate = text }
         case "itunes:duration":
             currentEpisode?.duration = text
-        case "itunes:summary" where currentEpisode?.summary.isEmpty == true:
-            currentEpisode?.summary = text
-        case "description" where currentEpisode?.summary.isEmpty == true:
-            currentEpisode?.summary = text
-        case "content", "content:encoded" where currentEpisode?.summary.isEmpty == true:
-            currentEpisode?.summary = text
+        // First one wins. A `where` on a multi-pattern case only guards the last
+        // pattern, so "content" used to clobber an already-parsed summary.
+        case "itunes:summary", "description", "content", "content:encoded":
+            if currentEpisode?.summary.isEmpty == true { currentEpisode?.summary = text }
         default: break
         }
     }

podcold/podcold/Networking/FeedParser.swift

@@ -62,7 +62,12 @@ class AudioPlayer: NSObject {
                 let dur = CMTimeGetSeconds(item.duration)
                 self.progressTick += 1
                 // Save position every 5s — avoids UserDefaults plist-flush stalls on main thread
-                if self.progressTick % 5 == 0 { self.currentEpisode?.savePosition(cur) }
+                if self.progressTick % 5 == 0 {
+                    self.currentEpisode?.savePosition(cur)
+                    // Cache the real length — itunes:duration is often missing or
+                    // wrong, and the Continue Listening progress bar needs a total
+                    if !dur.isNaN { self.currentEpisode?.saveDuration(dur) }
+                }
                 self.onProgress?(cur, dur.isNaN ? 0 : dur)
                 // Update lock-screen scrubber every 5s — iOS interpolates elapsed in-between
                 if self.progressTick % 5 == 0 {

podcold/podcold/Playback/AudioPlayer.swift

@@ -180,35 +180,103 @@ class EpisodeDetailVC: UIViewController {
             completion: { [weak self] _ in self?.updateDownloadButton(progress: nil) })
     }
 
+    // Show notes are HTML with no literal newlines — the paragraph structure
+    // lives entirely in the <p>/<br>/<li> tags. Dropping every tag therefore
+    // collapsed the whole description into one run-on block, so block-level
+    // tags are turned into line breaks before the rest are discarded.
     private static func stripHTML(_ s: String) -> String {
-        // Remove tags
         var out = ""
+        var tag = ""
         var inTag = false
         for c in s {
-            if c == "<" { inTag = true }
-            else if c == ">" { inTag = false }
-            else if !inTag { out.append(c) }
+            if c == "<" {
+                inTag = true
+                tag = ""
+            } else if c == ">" && inTag {
+                inTag = false
+                out += breakFor(tag: tag)
+            } else if inTag {
+                tag.append(c)
+            } else {
+                out.append(c)
+            }
+        }
+        return collapse(decodeEntities(out))
+    }
+
+    // "" for inline tags (<a>, <em>, <strong>…), a line break for block ones.
+    private static func breakFor(tag: String) -> String {
+        var t = tag.lowercased().trimmingCharacters(in: .whitespacesAndNewlines)
+        let closing = t.hasPrefix("/")
+        if closing { t.removeFirst() }
+        // Stop at the first attribute or at a self-closing slash: "br /" -> "br"
+        let name = t.components(separatedBy: CharacterSet(charactersIn: " \t\n\r/")).first ?? ""
+        switch name {
+        case "br":
+            return "\n"
+        case "li":
+            return closing ? "" : "\n\u{2022} "
+        case "p", "div", "blockquote", "pre", "ul", "ol", "table", "tr",
+             "h1", "h2", "h3", "h4", "h5", "h6":
+            return "\n\n"
+        default:
+            return ""
+        }
+    }
+
+    private static func decodeEntities(_ s: String) -> String {
+        var out = decodeNumericEntities(s)
+        // &amp; must come last, or "&amp;lt;" would wrongly end up as "<"
+        let named = [("&lt;", "<"), ("&gt;", ">"), ("&quot;", "\""),
+                     ("&apos;", "'"), ("&nbsp;", " "),
+                     ("&hellip;", "\u{2026}"), ("&mdash;", "\u{2014}"),
+                     ("&ndash;", "\u{2013}"),
+                     ("&rsquo;", "\u{2019}"), ("&lsquo;", "\u{2018}"),
+                     ("&rdquo;", "\u{201D}"), ("&ldquo;", "\u{201C}"),
+                     ("&amp;", "&")]
+        for (entity, replacement) in named {
+            out = out.replacingOccurrences(of: entity, with: replacement)
         }
-        // Decode common HTML entities
-        out = out.replacingOccurrences(of: "&amp;",  with: "&")
-        out = out.replacingOccurrences(of: "&lt;",   with: "<")
-        out = out.replacingOccurrences(of: "&gt;",   with: ">")
-        out = out.replacingOccurrences(of: "&quot;", with: "\"")
-        out = out.replacingOccurrences(of: "&#39;",  with: "'")
-        out = out.replacingOccurrences(of: "&nbsp;", with: " ")
-        // Collapse runs of whitespace/newlines left by removed block tags
-        var result = ""
-        var prevNewline = false
-        for c in out {
-            if c == "\n" || c == "\r" {
-                if !prevNewline { result.append("\n") }
-                prevNewline = true
+        return out
+    }
+
+    // Feeds lean heavily on &#8217; / &#x2019; for typographic punctuation —
+    // undecoded these showed up as literal noise mid-sentence.
+    private static func decodeNumericEntities(_ s: String) -> String {
+        let parts = s.components(separatedBy: "&#")
+        guard parts.count > 1 else { return s }
+        var out = parts[0]
+        for part in parts.dropFirst() {
+            guard let semi = part.firstIndex(of: ";") else { out += "&#" + part; continue }
+            var body = String(part[part.startIndex..<semi])
+            let rest = String(part[part.index(after: semi)...])
+            let value: UInt32?
+            if body.hasPrefix("x") || body.hasPrefix("X") {
+                body.removeFirst()
+                value = UInt32(body, radix: 16)
+            } else {
+                value = UInt32(body, radix: 10)
+            }
+            if let v = value, let scalar = UnicodeScalar(v) {
+                out += String(Character(scalar)) + rest
             } else {
-                prevNewline = false
-                result.append(c)
+                out += "&#" + part
             }
         }
-        return result.trimmingCharacters(in: .whitespacesAndNewlines)
+        return out
+    }
+
+    // Trim each line and allow at most one blank line between paragraphs.
+    private static func collapse(_ s: String) -> String {
+        let normalized = s.replacingOccurrences(of: "\r\n", with: "\n")
+                          .replacingOccurrences(of: "\r", with: "\n")
+        var lines: [String] = []
+        for raw in normalized.components(separatedBy: "\n") {
+            let line = raw.trimmingCharacters(in: .whitespaces)
+            if line.isEmpty && (lines.last?.isEmpty ?? true) { continue }
+            lines.append(line)
+        }
+        return lines.joined(separator: "\n").trimmingCharacters(in: .whitespacesAndNewlines)
     }
 
     @objc private func playTapped() {

podcold/podcold/ViewControllers/EpisodeDetailVC.swift

@@ -186,11 +186,15 @@ class HomeVC: UIViewController {
         lbl.numberOfLines = 3
         card.addSubview(lbl)
 
+        // Needs the episode's real length — a hardcoded assumed duration made
+        // every episode past that mark read as complete.
         let pos = episode.savedPosition()
-        if pos > 0 {
+        let total = episode.totalDuration()
+        if pos > 0 && total > 0 {
             let bar = UIView(frame: CGRect(x: 0, y: 98, width: 120, height: 3))
             bar.backgroundColor = UIColor(white: 0.2, alpha: 1)
-            let fill = UIView(frame: CGRect(x: 0, y: 0, width: min(120, CGFloat(pos / 1800) * 120), height: 3))
+            let fraction = min(1.0, pos / total)
+            let fill = UIView(frame: CGRect(x: 0, y: 0, width: CGFloat(fraction) * 120, height: 3))
             fill.backgroundColor = UIColor(red: 0.53, green: 0.26, blue: 0.73, alpha: 1)
             bar.addSubview(fill)
             card.addSubview(bar)