tracer/iKeyMon
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 5 Wiki Activity

add Sparkle appcast

Browse Source
This commit is contained in:
Micha
2025-11-25 16:21:07 +01:00
parent dc9560e31a
commit 01c89de738
18 changed files with 262 additions and 356 deletions
Download Patch File Download Diff File Expand all files Collapse all files

160
Sources/Model/Updates/UpdateService.swift
View File

@@ -1,160 +0,0 @@
import Foundation
struct ReleaseInfo: Identifiable {
let id = UUID()
let version: VersionNumber
let versionString: String
let notes: String
let downloadURL: URL
let releaseURL: URL
let prerelease: Bool
}
struct VersionNumber: Comparable, CustomStringConvertible {
let rawValue: String
private let components: [Int]
init(_ raw: String) {
self.rawValue = raw
self.components = raw
.split(separator: ".")
.map { Int($0) ?? 0 }
}
var description: String { rawValue }
static func < (lhs: VersionNumber, rhs: VersionNumber) -> Bool {
let maxCount = max(lhs.components.count, rhs.components.count)
for index in 0..<maxCount {
let left = index < lhs.components.count ? lhs.components[index] : 0
let right = index < rhs.components.count ? rhs.components[index] : 0
if left != right {
return left < right
}
}
return false
}
}
enum UpdateServiceError: LocalizedError {
case invalidResponse
case noReleasesAvailable
case missingDownloadAsset
var errorDescription: String? {
switch self {
case .invalidResponse:
return "The update server returned an invalid response."
case .noReleasesAvailable:
return "No releases are currently available."
case .missingDownloadAsset:
return "The release did not include downloadable artifacts."
}
}
}
struct UpdateService {
private struct APIRelease: Decodable {
struct Asset: Decodable {
let name: String
let browserDownloadURL: URL?
enum CodingKeys: String, CodingKey {
case name
case browserDownloadURL = "browser_download_url"
}
}
let tagName: String
let body: String?
let prerelease: Bool
let draft: Bool
let htmlURL: URL?
let createdAt: Date
let assets: [Asset]
enum CodingKeys: String, CodingKey {
case tagName = "tag_name"
case body
case prerelease
case draft
case htmlURL = "html_url"
case createdAt = "created_at"
case assets
}
}
private let baseURL = URL(string: "https://git.24unix.net/api/v1")!
private let owner = "tracer"
private let repo = "iKeyMon"
private let session: URLSession
init(session: URLSession = .shared) {
self.session = session
}
func fetchLatestRelease(includePrerelease: Bool) async throws -> ReleaseInfo {
let releasesURL = baseURL
.appendingPathComponent("repos")
.appendingPathComponent(owner)
.appendingPathComponent(repo)
.appendingPathComponent("releases")
var request = URLRequest(url: releasesURL)
request.addValue("application/json", forHTTPHeaderField: "Accept")
let (data, response) = try await session.data(for: request)
guard let httpResponse = response as? HTTPURLResponse,
200..<300 ~= httpResponse.statusCode else {
throw UpdateServiceError.invalidResponse
}
let decoder = JSONDecoder()
decoder.dateDecodingStrategy = .iso8601
let releases = try decoder.decode([APIRelease].self, from: data)
let filtered = releases
.filter { !$0.draft }
.filter { includePrerelease || !$0.prerelease }
.sorted(by: { $0.createdAt > $1.createdAt })
guard let release = filtered.first else {
throw UpdateServiceError.noReleasesAvailable
}
guard let asset = preferredAsset(from: release.assets),
let downloadURL = asset.browserDownloadURL else {
throw UpdateServiceError.missingDownloadAsset
}
let cleanTag = release.tagName.trimmingCharacters(in: .whitespacesAndNewlines)
let version = cleanTag.hasPrefix("v") ? String(cleanTag.dropFirst()) : cleanTag
return ReleaseInfo(
version: VersionNumber(version),
versionString: version,
notes: release.body ?? "",
downloadURL: downloadURL,
releaseURL: release.htmlURL ?? releasesURL,
prerelease: release.prerelease
)
}
private func preferredAsset(from assets: [APIRelease.Asset]) -> APIRelease.Asset? {
return assets
.sorted { lhs, rhs in
priority(for: lhs.name) > priority(for: rhs.name)
}
.first(where: { $0.browserDownloadURL != nil })
}
private func priority(for name: String) -> Int {
if name.lowercased().hasSuffix(".dmg") {
return 3
}
if name.lowercased().hasSuffix(".zip") {
return 2
}
return 1
}
}

26
Sources/ViewModels/SparkleUpdater.swift Normal file
View File

@@ -0,0 +1,26 @@
import Sparkle
import Foundation
@MainActor
final class SparkleUpdater: NSObject, ObservableObject {
let controller: SPUStandardUpdaterController
override init() {
self.controller = SPUStandardUpdaterController(startingUpdater: true, updaterDelegate: nil, userDriverDelegate: nil)
super.init()
}
var automaticallyChecksForUpdates: Bool {
get { controller.updater.automaticallyChecksForUpdates }
set { controller.updater.automaticallyChecksForUpdates = newValue }
}
var automaticallyDownloadsUpdates: Bool {
get { controller.updater.automaticallyDownloadsUpdates }
set { controller.updater.automaticallyDownloadsUpdates = newValue }
}
func checkForUpdates() {
controller.checkForUpdates(nil)
}
}

95
Sources/ViewModels/UpdateViewModel.swift
View File

@@ -1,95 +0,0 @@
import Foundation
#if os(macOS)
import AppKit
#endif
@MainActor
final class UpdateViewModel: ObservableObject {
struct StatusAlert: Identifiable {
let id = UUID()
let title: String
let message: String
}
@Published var availableRelease: ReleaseInfo?
@Published var latestFetchedRelease: ReleaseInfo?
@Published var statusAlert: StatusAlert?
@Published var isChecking = false
private let service: UpdateService
private let userDefaults: UserDefaults
private let autoCheckKey = "autoCheckUpdates"
private let includePrereleaseKey = "includePrereleaseUpdates"
init(service: UpdateService = UpdateService(), userDefaults: UserDefaults = .standard) {
self.service = service
self.userDefaults = userDefaults
registerDefaultsIfNeeded()
}
func startAutomaticCheckIfNeeded() {
if userDefaults.bool(forKey: autoCheckKey) {
checkForUpdates(userInitiated: false)
}
}
func checkForUpdates(userInitiated: Bool) {
guard !isChecking else { return }
isChecking = true
Task {
do {
let release = try await service.fetchLatestRelease(includePrerelease: userDefaults.bool(forKey: includePrereleaseKey))
handle(release: release, userInitiated: userInitiated)
} catch {
if userInitiated {
statusAlert = StatusAlert(
title: "Update Check Failed",
message: error.localizedDescription
)
}
}
self.isChecking = false
}
}
func openReleaseNotes() {
guard let releaseURL = availableRelease?.releaseURL ?? latestFetchedRelease?.releaseURL else { return }
#if os(macOS)
NSWorkspace.shared.open(releaseURL)
#endif
}
func downloadLatest() {
let release = availableRelease ?? latestFetchedRelease
availableRelease = nil
guard let downloadURL = release?.downloadURL else { return }
#if os(macOS)
NSWorkspace.shared.open(downloadURL)
#endif
}
private func handle(release: ReleaseInfo, userInitiated: Bool) {
let currentVersion = VersionNumber(
Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "0.0.0"
)
latestFetchedRelease = release
if release.version > currentVersion {
availableRelease = release
} else if userInitiated {
statusAlert = StatusAlert(
title: "You're Up To Date",
message: "iKeyMon \(currentVersion.rawValue) is the latest version."
)
}
}
private func registerDefaultsIfNeeded() {
userDefaults.register(defaults: [
autoCheckKey: true,
includePrereleaseKey: true
])
}
}

47
Sources/Views/MainView.swift
View File

@@ -12,15 +12,13 @@ struct MainView: View {
private static let serverOrderKeyStatic = "serverOrder"
private static let storedServersKeyStatic = "storedServers"
@EnvironmentObject private var updateViewModel: UpdateViewModel
@EnvironmentObject private var sparkleUpdater: SparkleUpdater
@State var showAddServerSheet: Bool = false
@State private var serverBeingEdited: Server?
@State private var serverToDelete: Server?
@State private var showDeleteConfirmation = false
@State private var isFetchingInfo: Bool = false
@State private var refreshTimer = Timer.publish(every: 60, on: .main, in: .common).autoconnect()
@State private var progress: Double = 0
@State private var lastRefresh = Date()
@State private var pingTimer: Timer?
private let serverOrderKey = MainView.serverOrderKeyStatic
private let storedServersKey = MainView.storedServersKeyStatic
@@ -64,14 +62,9 @@ struct MainView: View {
}
ToolbarItem {
Button {
updateViewModel.checkForUpdates(userInitiated: true)
sparkleUpdater.checkForUpdates()
} label: {
if updateViewModel.isChecking {
ProgressView()
.scaleEffect(0.6)
} else {
Image(systemName: "square.and.arrow.down")
}
Image(systemName: "square.and.arrow.down")
}
.help("Check for Updates")
}
@@ -144,26 +137,8 @@ struct MainView: View {
pingTimer = Timer.scheduledTimer(withTimeInterval: 10.0, repeats: true) { _ in
pingAllServers()
}
updateViewModel.startAutomaticCheckIfNeeded()
}
.frame(minWidth: 800, minHeight: 450)
.alert(item: availableReleaseBinding) { release in
Alert(
title: Text("Update Available"),
message: Text("iKeyMon \(release.versionString) is available."),
primaryButton: .default(Text("Download")) {
updateViewModel.downloadLatest()
},
secondaryButton: .cancel(Text("Later"))
)
}
.alert(item: statusAlertBinding) { alert in
Alert(
title: Text(alert.title),
message: Text(alert.message),
dismissButton: .default(Text("OK"))
)
}
}
private func fetchServerInfo(for id: UUID) {
@@ -290,23 +265,9 @@ struct MainView: View {
return []
}
}
private var availableReleaseBinding: Binding<ReleaseInfo?> {
Binding(
get: { updateViewModel.availableRelease },
set: { updateViewModel.availableRelease = $0 }
)
}
private var statusAlertBinding: Binding<UpdateViewModel.StatusAlert?> {
Binding(
get: { updateViewModel.statusAlert },
set: { updateViewModel.statusAlert = $0 }
)
}
}
#Preview {
MainView()
.environmentObject(UpdateViewModel())
.environmentObject(SparkleUpdater())
}

66
Sources/Views/PreferencesView.swift
View File

@@ -22,13 +22,11 @@ struct PreferencesView: View {
}
}
}
@EnvironmentObject private var updateViewModel: UpdateViewModel
@EnvironmentObject private var sparkleUpdater: SparkleUpdater
@AppStorage("pingInterval") private var storedPingInterval: Int = 10
@AppStorage("refreshInterval") private var storedRefreshInterval: Int = 60
@AppStorage("showIntervalIndicator") private var showIntervalIndicator: Bool = true
@AppStorage("autoCheckUpdates") private var autoCheckUpdates: Bool = true
@AppStorage("includePrereleaseUpdates") private var includePrereleaseUpdates: Bool = true
@State private var pingIntervalSlider: Double = 10
@State private var refreshIntervalSlider: Double = 60
@@ -126,11 +124,8 @@ struct PreferencesView: View {
case .alerts:
AlertsPreferencesView()
case .updates:
UpdatesPreferencesView(
autoCheckUpdates: $autoCheckUpdates,
includePrereleaseUpdates: $includePrereleaseUpdates
)
.environmentObject(updateViewModel)
UpdatesPreferencesView()
.environmentObject(sparkleUpdater)
}
}
}
@@ -232,46 +227,39 @@ private struct MonitorPreferencesView: View {
}
private struct UpdatesPreferencesView: View {
@Binding var autoCheckUpdates: Bool
@Binding var includePrereleaseUpdates: Bool
@EnvironmentObject var updateViewModel: UpdateViewModel
@EnvironmentObject var sparkleUpdater: SparkleUpdater
private var automaticallyChecksBinding: Binding<Bool> {
Binding(
get: { sparkleUpdater.automaticallyChecksForUpdates },
set: { sparkleUpdater.automaticallyChecksForUpdates = $0 }
)
}
private var automaticallyDownloadsBinding: Binding<Bool> {
Binding(
get: { sparkleUpdater.automaticallyDownloadsUpdates },
set: { sparkleUpdater.automaticallyDownloadsUpdates = $0 }
)
}
var body: some View {
VStack(alignment: .leading, spacing: 16) {
Toggle("Automatically check for updates", isOn: $autoCheckUpdates)
.toggleStyle(.switch)
VStack(alignment: .leading, spacing: 18) {
Toggle("Automatically check for updates", isOn: automaticallyChecksBinding)
Toggle("Automatically download updates", isOn: automaticallyDownloadsBinding)
Toggle("Include pre-release builds", isOn: $includePrereleaseUpdates)
.toggleStyle(.switch)
HStack {
if updateViewModel.isChecking {
ProgressView()
.progressViewStyle(.circular)
Text("Checking for updates…")
.foregroundColor(.secondary)
} else {
Button("Check Now") {
updateViewModel.checkForUpdates(userInitiated: true)
}
}
Button(action: sparkleUpdater.checkForUpdates) {
Label("Check for Updates Now", systemImage: "sparkles")
}
if let release = updateViewModel.latestFetchedRelease {
VStack(alignment: .leading, spacing: 4) {
Text("Latest available: \(release.versionString)")
.font(.subheadline)
if release.prerelease {
Text("Pre-release build")
.font(.caption)
.foregroundColor(.secondary)
}
}
Text("Updates are delivered via Sparkle. Configure your appcast URL and public EdDSA key in Info.plist (keys `SUFeedURL` and `SUPublicEDKey`).")
.font(.caption)
.foregroundColor(.secondary)
.padding(.top, 4)
}
Spacer()
}
.toggleStyle(.switch)
.frame(maxWidth: .infinity, alignment: .leading)
}
}

6
Sources/iKeyMonApp.swift
View File

@@ -12,7 +12,7 @@ import AppKit
@main
struct iKeyMonApp: App {
@StateObject private var updateViewModel = UpdateViewModel()
@StateObject private var sparkleUpdater = SparkleUpdater()
init() {
#if os(macOS)
@@ -25,7 +25,7 @@ struct iKeyMonApp: App {
var body: some Scene {
WindowGroup {
MainView()
.environmentObject(updateViewModel)
.environmentObject(sparkleUpdater)
.onDisappear {
NSApp.terminate(nil)
}
@@ -35,7 +35,7 @@ struct iKeyMonApp: App {
Settings {
PreferencesView()
.padding()
.environmentObject(updateViewModel)
.environmentObject(sparkleUpdater)
}
}
}