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

included Sparkle

Browse Source
This commit is contained in:
Micha
2025-11-22 18:56:55 +01:00
parent db1f15f981
commit dc710d53aa
15 changed files with 579 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
Sources/Extensions/View+Shimmer.swift
View File

@@ -15,11 +15,10 @@ struct ShimmerModifier: ViewModifier {
guard active else { return }
animate()
}
.onChange(of: active) { isActive in
if isActive {
phase = -1
animate()
}
.onChange(of: active) {
guard active else { return }
phase = -1
animate()
}
}

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

@@ -0,0 +1,160 @@
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
}
}

95
Sources/ViewModels/UpdateViewModel.swift Normal file
View File

@@ -0,0 +1,95 @@
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
])
}
}

56
Sources/Views/MainView.swift
View File

@@ -12,6 +12,7 @@ struct MainView: View {
private static let serverOrderKeyStatic = "serverOrder"
private static let storedServersKeyStatic = "storedServers"
@EnvironmentObject private var updateViewModel: UpdateViewModel
@State var showAddServerSheet: Bool = false
@State private var serverBeingEdited: Server?
@State private var serverToDelete: Server?
@@ -30,9 +31,9 @@ struct MainView: View {
@State private var selectedServerID: UUID?
var body: some View {
NavigationSplitView {
List(selection: $selectedServerID) {
var mainContent: some View {
NavigationSplitView {
List(selection: $selectedServerID) {
ForEach(servers) { server in
HStack {
Image(systemName: "dot.circle.fill")
@@ -61,6 +62,19 @@ struct MainView: View {
}
.help("Add Host")
}
ToolbarItem {
Button {
updateViewModel.checkForUpdates(userInitiated: true)
} label: {
if updateViewModel.isChecking {
ProgressView()
.scaleEffect(0.6)
} else {
Image(systemName: "square.and.arrow.down")
}
}
.help("Check for Updates")
}
}
.navigationTitle("Servers")
.onChange(of: selectedServerID) {
@@ -76,7 +90,9 @@ struct MainView: View {
} else {
ContentUnavailableView("No Server Selected", systemImage: "server.rack")
}
}
}
return mainContent
.sheet(isPresented: $showAddServerSheet) {
ServerFormView(
mode: .add,
@@ -128,9 +144,26 @@ 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) {
@@ -257,8 +290,23 @@ 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())
}

66
Sources/Views/PreferencesView.swift
View File

@@ -2,13 +2,14 @@ import SwiftUI
struct PreferencesView: View {
private enum Tab: CaseIterable {
case monitor, notifications, alerts
case monitor, notifications, alerts, updates
var title: String {
switch self {
case .monitor: return "Monitor"
case .notifications: return "Notifications"
case .alerts: return "Alerts"
case .updates: return "Updates"
}
}
@@ -17,13 +18,17 @@ struct PreferencesView: View {
case .monitor: return "waveform.path.ecg"
case .notifications: return "bell.badge"
case .alerts: return "exclamationmark.triangle"
case .updates: return "square.and.arrow.down"
}
}
}
@EnvironmentObject private var updateViewModel: UpdateViewModel
@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
@@ -77,14 +82,14 @@ struct PreferencesView: View {
.padding(.vertical, 8)
.padding(.horizontal, 10)
.frame(maxWidth: .infinity, alignment: .leading)
.background(
Capsule(style: .continuous)
.fill(backgroundColor(for: tab))
)
}
.buttonStyle(.plain)
.focusable(false)
.contentShape(Capsule())
.background(
Capsule(style: .continuous)
.fill(backgroundColor(for: tab))
)
.foregroundColor(selection == tab ? .white : .primary)
.onHover { isHovering in
hoveredTab = isHovering ? tab : (hoveredTab == tab ? nil : hoveredTab)
@@ -120,6 +125,12 @@ struct PreferencesView: View {
NotificationsPreferencesView()
case .alerts:
AlertsPreferencesView()
case .updates:
UpdatesPreferencesView(
autoCheckUpdates: $autoCheckUpdates,
includePrereleaseUpdates: $includePrereleaseUpdates
)
.environmentObject(updateViewModel)
}
}
}
@@ -220,6 +231,51 @@ private struct MonitorPreferencesView: View {
}
}
private struct UpdatesPreferencesView: View {
@Binding var autoCheckUpdates: Bool
@Binding var includePrereleaseUpdates: Bool
@EnvironmentObject var updateViewModel: UpdateViewModel
var body: some View {
VStack(alignment: .leading, spacing: 16) {
Toggle("Automatically check for updates", isOn: $autoCheckUpdates)
.toggleStyle(.switch)
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)
}
}
}
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)
}
}
.padding(.top, 4)
}
Spacer()
}
.frame(maxWidth: .infinity, alignment: .leading)
}
}
private struct NotificationsPreferencesView: View {
var body: some View {
VStack(alignment: .leading, spacing: 12) {

5
Sources/Views/Tabs/GeneralView.swift
View File

@@ -59,10 +59,11 @@ struct GeneralView: View {
var description = os.label.trimmingCharacters(in: .whitespacesAndNewlines)
if description.isEmpty {
description = distro
} else if !distro.isEmpty && distro.caseInsensitiveCompare(description) != .orderedSame {
} else if !distro.isEmpty && description.range(of: distro, options: [.caseInsensitive]) == nil {
description += " • \(distro)"
}
if !os.architecture.isEmpty {
if !os.architecture.isEmpty &&
description.range(of: os.architecture, options: [.caseInsensitive]) == nil {
description += " (\(os.architecture))"
}
if !description.isEmpty {

4
Sources/iKeyMonApp.swift
View File

@@ -12,6 +12,8 @@ import AppKit
@main
struct iKeyMonApp: App {
@StateObject private var updateViewModel = UpdateViewModel()
init() {
#if os(macOS)
if let customIcon = NSImage(named: "AppIcon") {
@@ -23,6 +25,7 @@ struct iKeyMonApp: App {
var body: some Scene {
WindowGroup {
MainView()
.environmentObject(updateViewModel)
.onDisappear {
NSApp.terminate(nil)
}
@@ -32,6 +35,7 @@ struct iKeyMonApp: App {
Settings {
PreferencesView()
.padding()
.environmentObject(updateViewModel)
}
}
}