Skip to content

Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more

3.5 KB
Raw Blame
import Foundation

/// Main-thread callers serialize requests; tokens reject delayed callbacks from old sheets.
struct ReleaseHighlightsPolicy {
    static let seenKey = "FluidVoiceSeenReleaseHighlightVersions"
    static let historyLimit = 32

    struct Session: Equatable, Identifiable {
        let id = UUID()
        let owner: UUID
        let version: String
        let build: String
        let manual: Bool
        var dismissing = false
        var acknowledge = false
    }

    private(set) var seenVersions: [String]
    private(set) var session: Session?
    private var manualRequests: Set<UUID> = []

    init(seenVersions: [String] = []) {
        var unique: [String] = []
        for version in seenVersions where !version.isEmpty {
            unique.removeAll { $0 == version }
            unique.append(version)
        }
        self.seenVersions = Array(unique.suffix(Self.historyLimit))
    }

    static func updateID(version: String, build: String) -> String {
        build.isEmpty ? version : "\(version) (\(build))"
    }

    mutating func requestManual(owner: UUID) {
        // Repeated requests for an already-open sheet must not queue a second popup.
        guard self.session?.owner != owner else { return }
        self.manualRequests.insert(owner)
    }

    mutating func request(owner: UUID, version: String, build: String = "", eligible: Bool, manual: Bool = false) -> Session? {
        if manual { self.requestManual(owner: owner) }
        // Content may describe an earlier release. Every newly installed version/build
        // still gets a presentation, without interrupting an ineligible activity.
        guard eligible, self.session == nil, !version.isEmpty,
              self.manualRequests.contains(owner) || !self.seenVersions.contains(Self.updateID(version: version, build: build)) else { return nil }
        let session = Session(owner: owner, version: version, build: build, manual: self.manualRequests.contains(owner))
        self.manualRequests.remove(owner)
        self.session = session
        return session
    }

    mutating func beginDismiss(id: UUID, acknowledge: Bool) -> Bool {
        guard var session = self.session, session.id == id, !session.dismissing else { return false }
        session.dismissing = true
        session.acknowledge = acknowledge
        self.session = session
        return true
    }

    mutating func interrupt(id: UUID) {
        guard var session = self.session, session.id == id else { return }
        session.dismissing = true
        session.acknowledge = false
        self.session = session
    }

    /// Returns nil for stale callbacks. A system dismissal counts as a close only if still eligible.
    mutating func finishDismiss(id: UUID, eligible: Bool) -> Bool? {
        guard let session = self.session, session.id == id else { return nil }
        self.session = nil
        let acknowledged = eligible && (!session.dismissing || session.acknowledge)
        if !acknowledged, session.manual { self.manualRequests.insert(session.owner) }
        if acknowledged {
            let updateID = Self.updateID(version: session.version, build: session.build)
            self.seenVersions.removeAll { $0 == updateID }
            self.seenVersions.append(updateID)
            self.seenVersions = Array(self.seenVersions.suffix(Self.historyLimit))
        }
        return acknowledged
    }

    mutating func abandon(owner: UUID) {
        self.manualRequests.remove(owner)
        guard self.session?.owner == owner else { return }
        self.session = nil
    }
}