6 | 
7 | 
8 | 
9 | 
10 | 
11 |
16 | 
17 |
HiPixel
20 | 21 |
22 |
23 | 
24 |
25 |
26 | 
27 |
28 |
29 | 
30 |
31 |
32 | 
33 |
34 |
47 | 
48 |
176 |
177 | 
220 | 
221 |
224 |
239 |
240 | 您的支持将帮助我们持续改进 HiPixel！
241 |
242 | ### 👉 推荐工具
243 |
244 | - **[Zipic](https://zipic.app)** - 智能图像压缩工具，搭配 AI 优化技术
245 | - 🔄 **完美搭配**: 使用 HiPixel 放大图像后，用 Zipic 进行智能压缩，在保持清晰度的同时减小文件体积
246 | - 🎯 **工作流建议**: HiPixel 放大 → Zipic 压缩 → 输出优化图像
247 | - ✨ **效果提升**: 相比单独使用任一工具，联合使用可获得质量与体积的最佳平衡
248 |
249 | 探索更多 [5KM Tech](https://5km.tech) 为复杂任务带来简单解决方案的产品。
250 |
251 | ### 🙏 致谢
252 |
253 | HiPixel 使用了以下来自 [Upscayl](https://github.com/upscayl/upscayl) 的组件：
254 |
255 | - upscayl-bin - AI 超分辨率处理工具
256 | - AI Models - 图像超分辨率模型
257 |
258 | 特别感谢 [zaotang.xyz](https://zaotang.xyz) 为 HiPixel v0.2 版本设计了全新的应用图标和主窗口交互界面。
259 |
260 | HiPixel 还使用了：
261 |
262 | - [FSWatcher](https://github.com/okooo5km/FSWatcher) - 高性能的 Swift 原生文件系统监控库，支持 macOS 和 iOS 智能监听 (MIT 许可证)
263 | - [Sparkle](https://github.com/sparkle-project/Sparkle) - macOS 应用程序的软件更新框架 (MIT 许可证)
264 | - [NotchNotification](https://github.com/Lakr233/NotchNotification) - 适用于 macOS 的刘海屏样式通知横幅 (MIT 许可证)
265 | - [GeneralNotification](https://github.com/okooo5km/GeneralNotification) - 适用于 macOS 的自定义通知横幅 (MIT 许可证)
266 |
267 |
--------------------------------------------------------------------------------
/HiPixel/Services/UpscaleImagesIntent.swift:
--------------------------------------------------------------------------------
1 | //
2 | // UpscaleImagesIntent.swift
3 | // HiPixel
4 | //
5 | // Created by 十里 on 2025/11/10.
6 | //
7 |
8 | import AppIntents
9 | import Foundation
10 | import SwiftUI
11 |
12 | struct UpscaleImagesIntent: AppIntent {
13 | static var title: LocalizedStringResource = "Upscale Images"
14 | static var description = IntentDescription("Upscale images using AI with HiPixel.")
15 |
16 | @Parameter(title: "Files", description: "Image files or folders to upscale")
17 | var files: [IntentFile]
18 |
19 | @Parameter(title: "Image Scale", description: "Upscaling factor (multiplier)", default: 4.0)
20 | var imageScale: Double?
21 |
22 | @Parameter(title: "Save Format", description: "Output image format")
23 | var saveImageAs: ImageFormatEnum?
24 |
25 | @Parameter(title: "Double Upscayl", description: "Enable double upscaling (upscale twice)", default: false)
26 | var doubleUpscayl: Bool?
27 |
28 | @Parameter(title: "Enable TTA", description: "Enable Test Time Augmentation for better quality", default: false)
29 | var enableTTA: Bool?
30 |
31 | @Parameter(title: "Compression Level", description: "Compression level (0-99)")
32 | var imageCompression: Int?
33 |
34 | @Parameter(
35 | title: "Enable Zipic Compression", description: "Enable Zipic compression (requires Zipic app)", default: false)
36 | var enableZipicCompression: Bool?
37 |
38 | @Parameter(title: "Custom Output Folder", description: "Custom folder path for output images")
39 | var saveOutputFolder: String?
40 |
41 | @Parameter(title: "GPU ID", description: "GPU ID to use for processing")
42 | var gpuID: String?
43 |
44 | @Parameter(title: "Custom Tile Size", description: "Custom tile size for processing (0 uses default)")
45 | var customTileSize: Int?
46 |
47 | @Parameter(title: "Upscayl Model", description: "Built-in AI model to use")
48 | var upscaylModel: UpscaylModelEnum?
49 |
50 | @Parameter(title: "Selected Custom Model", description: "Custom model name to use")
51 | var selectedCustomModel: String?
52 |
53 | static var parameterSummary: some ParameterSummary {
54 | Summary {
55 | \.$files
56 | \.$imageScale
57 | \.$saveImageAs
58 | \.$doubleUpscayl
59 | \.$enableTTA
60 | \.$imageCompression
61 | \.$enableZipicCompression
62 | \.$saveOutputFolder
63 | \.$gpuID
64 | \.$customTileSize
65 | \.$upscaylModel
66 | \.$selectedCustomModel
67 | }
68 | }
69 |
70 | func perform() async throws -> some IntentResult & ProvidesDialog {
71 | // Convert IntentFile to URLs
72 | let urls = files.compactMap { file -> URL? in
73 | // Prefer fileURL if available
74 | if let url = file.fileURL, url.isFileURL {
75 | return url
76 | }
77 | // Fallback: try to write data to temporary file if it's image data
78 | let data = file.data
79 | if !data.isEmpty {
80 | // Check if data looks like image data by checking first bytes
81 | let imageSignatures: [Data] = [
82 | Data([0x89, 0x50, 0x4E, 0x47]), // PNG
83 | Data([0xFF, 0xD8, 0xFF]), // JPEG
84 | ]
85 | if imageSignatures.contains(where: { data.prefix($0.count) == $0 }) {
86 | let tmp = FileManager.default.temporaryDirectory
87 | .appendingPathComponent(UUID().uuidString)
88 | .appendingPathExtension("jpg")
89 | try? data.write(to: tmp)
90 | return tmp
91 | }
92 | }
93 | return nil
94 | }
95 |
96 | guard !urls.isEmpty else {
97 | return .result(dialog: IntentDialog(stringLiteral: String(localized: "No valid image files provided.")))
98 | }
99 |
100 | // Validate URLs - check if they exist and are images or folders
101 | let validURLs = urls.compactMap { url -> URL? in
102 | guard FileManager.default.fileExists(atPath: url.path) else {
103 | return nil
104 | }
105 | guard url.isImageFile || url.isFile(ofTypes: [.folder]) else {
106 | return nil
107 | }
108 | return url
109 | }
110 |
111 | guard !validURLs.isEmpty else {
112 | return .result(
113 | dialog: IntentDialog(stringLiteral: String(localized: "No valid image files or folders found.")))
114 | }
115 |
116 | // Build UpscaylOptions from parameters
117 | let options = buildOptions()
118 |
119 | // Collect all image URLs to process
120 | var allImageURLs: [URL] = []
121 | for url in validURLs {
122 | if url.hasDirectoryPath {
123 | allImageURLs.append(contentsOf: url.imageContents)
124 | } else {
125 | allImageURLs.append(url)
126 | }
127 | }
128 |
129 | guard !allImageURLs.isEmpty else {
130 | return .result(
131 | dialog: IntentDialog(stringLiteral: String(localized: "No valid image files or folders found.")))
132 | }
133 |
134 | // Process images sequentially and wait for completion
135 | var successCount = 0
136 | var failedCount = 0
137 |
138 | for imageURL in allImageURLs {
139 | guard imageURL.fileSize > 0 else { continue }
140 |
141 | let item = UpscaylDataItem(imageURL)
142 |
143 | // Process each image and wait for completion using continuation
144 | let result = await withCheckedContinuation { (continuation: CheckedContinuation更多支持方式
225 | 226 | - 🛍️ **[通过 LemonSqueezy 一次性支持](https://okooo5km.lemonsqueezy.com/buy/4f1e3249-2683-4000-acd4-6b05ae117b40?discount=0)** 227 | 228 | - **微信支付** 229 |
230 | 
231 |
235 | 
236 |
6 |
7 |
8 |
9 |
10 |
11 |
16 |
17 |
HiPixel
20 | 21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
47 |
48 |
176 |
177 | 
220 |
221 |
224 |
241 |
242 | Your support helps maintain and improve HiPixel!
243 |
244 | ### 👉 Recommended Tool
245 |
246 | - **[Zipic](https://zipic.app)** - Smart image compression tool with AI optimization
247 | - 🔄 **Perfect Pairing**: After upscaling images with HiPixel, use Zipic for intelligent compression to reduce file size while maintaining clarity
248 | - 🎯 **Workflow Suggestion**: HiPixel upscaling → Zipic compression → Optimized output image
249 | - ✨ **Enhanced Results**: Compared to using either tool alone, combined use provides the optimal balance of quality and file size
250 |
251 | Explore more [5KM Tech](https://5km.tech) products that bring simplicity to complex tasks.
252 |
253 | ### 🙏 Attribution
254 |
255 | HiPixel uses the following components from [Upscayl](https://github.com/upscayl/upscayl):
256 |
257 | - upscayl-bin - The binary tool for AI upscaling (AGPLv3)
258 | - AI Models - The AI models for image super-resolution (AGPLv3)
259 |
260 | Special thanks to [zaotang.xyz](https://zaotang.xyz) for designing the new application icon and main window interaction interface for HiPixel v0.2.
261 |
262 | HiPixel also uses:
263 |
264 | - [FSWatcher](https://github.com/okooo5km/FSWatcher) - A high-performance, Swift-native file system watcher for macOS and iOS with intelligent monitoring (MIT License)
265 | - [Sparkle](https://github.com/sparkle-project/Sparkle) - A software update framework for macOS applications (MIT License)
266 | - [NotchNotification](https://github.com/Lakr233/NotchNotification) - A custom notch-style notification banner for macOS (MIT License)
267 | - [GeneralNotification](https://github.com/okooo5km/GeneralNotification) - A custom notification banner for macOS (MIT License)
268 |
--------------------------------------------------------------------------------
/HiPixel/Views/ImageComparationViewer.swift:
--------------------------------------------------------------------------------
1 | //
2 | // ImageComparationViewer.swift
3 | // HiPixel
4 | //
5 | // Created by 十里 on 2024/11/3.
6 | //
7 |
8 | import SwiftUI
9 |
10 | struct ImageComparationViewer: View {
11 |
12 | var leftImage: URL
13 | var rightImage: URL
14 |
15 | @State
16 | private var sliderPosition: CGFloat = 0.5 // Initial slider position
17 |
18 | @State
19 | private var hoveringOnSlider = false
20 |
21 | @State
22 | private var magnification: CGFloat = 1.0 // Zoom scale
23 |
24 | @State
25 | private var offset: CGSize = .zero // Drag offset
26 |
27 | @State
28 | private var lastMagnification: CGFloat = 1.0
29 |
30 | @State
31 | private var lastOffset: CGSize = .zero
32 |
33 | @State
34 | private var isDraggingSlider = false // Track if slider is being dragged
35 |
36 | @State
37 | private var hoveredZoomButton: ZoomButtonType? = nil // Track hovered button
38 |
39 | private let minMagnification: CGFloat = 1.0
40 | private let maxMagnification: CGFloat = 5.0
41 | private let zoomStep: CGFloat = 0.25 // Zoom step size
42 |
43 | var body: some View {
44 | GeometryReader { geometry in
45 | let imageSize = NSImage(contentsOf: leftImage)?.size ?? geometry.size
46 | let imageWidth = imageSize.width * geometry.size.height / imageSize.height
47 |
48 | // Calculate scaled image size and drag limits
49 | let scaledWidth = geometry.size.width * magnification
50 | let scaledHeight = geometry.size.height * magnification
51 | let maxOffsetX = max(0, (scaledWidth - geometry.size.width) / 2)
52 | let maxOffsetY = max(0, (scaledHeight - geometry.size.height) / 2)
53 |
54 | // Calculate slider drag range considering zoom
55 | let scaledImageWidth = imageWidth * magnification
56 | let scaledImageHalfWidth = scaledImageWidth / 2
57 |
58 | // If scaled image width >= view width, slider can drag to edges
59 | // Otherwise calculate range based on scaled image size
60 | let minPosition =
61 | scaledImageWidth >= geometry.size.width
62 | ? 0.001
63 | : max(0.5 - scaledImageHalfWidth / geometry.size.width, 0.001)
64 | let maxPosition =
65 | scaledImageWidth >= geometry.size.width
66 | ? 0.999
67 | : min(0.5 + scaledImageHalfWidth / geometry.size.width, 0.999)
68 |
69 | ZStack(alignment: .leading) {
70 | AsyncImage(url: rightImage) { image in
71 | image
72 | .resizable()
73 | .aspectRatio(contentMode: .fit)
74 | .frame(width: geometry.size.width, height: geometry.size.height)
75 | .scaleEffect(magnification)
76 | .offset(offset)
77 | } placeholder: {
78 | Color.gray
79 | }
80 | .mask(
81 | HStack {
82 | Spacer()
83 | Rectangle()
84 | .frame(width: (1 - sliderPosition) * geometry.size.width)
85 | }
86 | )
87 |
88 | AsyncImage(url: leftImage) { image in
89 | image
90 | .resizable()
91 | .aspectRatio(contentMode: .fit)
92 | .frame(width: geometry.size.width, height: geometry.size.height)
93 | .scaleEffect(magnification)
94 | .offset(offset)
95 | } placeholder: {
96 | Color.gray
97 | }
98 | .mask(
99 | HStack {
100 | Rectangle()
101 | .frame(width: sliderPosition * geometry.size.width)
102 | Spacer()
103 | }
104 | )
105 |
106 | ZStack {
107 | VStack(spacing: 0) {
108 | Rectangle()
109 | .frame(width: 2)
110 | .foregroundStyle(.clear)
111 | .background(.white.opacity(0.9))
112 |
113 | Rectangle()
114 | .frame(width: 2, height: 36)
115 | .foregroundStyle(.clear)
116 | .background(.clear)
117 |
118 | Rectangle()
119 | .frame(width: 2)
120 | .foregroundStyle(.clear)
121 | .background(.white.opacity(0.9))
122 | }
123 | .shadow(radius: 1, x: 0, y: 0)
124 |
125 | Circle()
126 | .fill(.white.opacity(0.8))
127 | .frame(width: 36, height: 36)
128 | .shadow(radius: 1, x: 0, y: 0)
129 |
130 | Circle()
131 | .stroke(.white, lineWidth: 2)
132 | .frame(width: 36, height: 36)
133 | .shadow(radius: 1, x: 0, y: 0)
134 |
135 | HStack(spacing: 4) {
136 | Image(systemName: "arrowtriangle.left.fill")
137 | Image(systemName: "arrowtriangle.right.fill")
138 | }
139 | .font(.system(size: 10))
140 | .foregroundStyle(.white)
141 | }
142 | .opacity(hoveringOnSlider ? 1.0 : 0.8)
143 | .offset(x: sliderPosition * geometry.size.width - 18)
144 | .highPriorityGesture(
145 | DragGesture()
146 | .onChanged { value in
147 | isDraggingSlider = true
148 | sliderPosition = min(max(minPosition, value.location.x / geometry.size.width), maxPosition)
149 | }
150 | .onEnded { _ in
151 | isDraggingSlider = false
152 | }
153 | )
154 | .onHover { hovering in
155 | if hovering {
156 | NSCursor.resizeLeftRight.set()
157 | hoveringOnSlider = true
158 | } else {
159 | NSCursor.arrow.set()
160 | hoveringOnSlider = false
161 | }
162 | }
163 | }
164 | .cornerRadius(6)
165 | .overlay(alignment: .bottomLeading) {
166 | ZoomControlsView(
167 | magnification: $magnification,
168 | lastMagnification: $lastMagnification,
169 | offset: $offset,
170 | lastOffset: $lastOffset,
171 | hoveredButton: $hoveredZoomButton,
172 | minMagnification: minMagnification,
173 | maxMagnification: maxMagnification,
174 | zoomStep: zoomStep
175 | )
176 | .padding(8)
177 | }
178 | .gesture(
179 | MagnificationGesture()
180 | .onChanged { value in
181 | let newMagnification = lastMagnification * value
182 | magnification = min(max(1.0, newMagnification), 5.0) // Limit zoom range 1x-5x
183 | }
184 | .onEnded { value in
185 | lastMagnification = magnification
186 | }
187 | )
188 | .simultaneousGesture(
189 | DragGesture(minimumDistance: 5)
190 | .onChanged { value in
191 | // Ignore image drag if slider is being dragged
192 | guard !isDraggingSlider else { return }
193 |
194 | // Only allow drag when zoomed in
195 | guard magnification > 1.0 else { return }
196 |
197 | // Check if in slider area to avoid conflict with slider drag
198 | let sliderX = sliderPosition * geometry.size.width
199 | let sliderRect = CGRect(
200 | x: sliderX - 30,
201 | y: 0,
202 | width: 60,
203 | height: geometry.size.height
204 | )
205 | if sliderRect.contains(value.startLocation) {
206 | return
207 | }
208 |
209 | let newOffsetX = lastOffset.width + value.translation.width
210 | let newOffsetY = lastOffset.height + value.translation.height
211 |
212 | // Limit drag range
213 | offset = CGSize(
214 | width: min(max(-maxOffsetX, newOffsetX), maxOffsetX),
215 | height: min(max(-maxOffsetY, newOffsetY), maxOffsetY)
216 | )
217 | }
218 | .onEnded { _ in
219 | if !isDraggingSlider {
220 | lastOffset = offset
221 | }
222 | }
223 | )
224 | .onTapGesture(count: 2) {
225 | // Double tap to reset zoom and position
226 | resetZoom()
227 | }
228 | }
229 | .clipShape(RoundedRectangle(cornerRadius: 6))
230 | .contentShape(RoundedRectangle(cornerRadius: 6))
231 | }
232 |
233 | private func resetZoom() {
234 | withAnimation(.spring(response: 0.3, dampingFraction: 0.7)) {
235 | magnification = 1.0
236 | offset = .zero
237 | lastMagnification = 1.0
238 | lastOffset = .zero
239 | }
240 | }
241 | }
242 |
243 | // MARK: - Zoom Controls
244 |
245 | enum ZoomButtonType {
246 | case zoomIn
247 | case zoomOut
248 | }
249 |
250 | struct ZoomControlsView: View {
251 | @Binding var magnification: CGFloat
252 | @Binding var lastMagnification: CGFloat
253 | @Binding var offset: CGSize
254 | @Binding var lastOffset: CGSize
255 | @Binding var hoveredButton: ZoomButtonType?
256 |
257 | let minMagnification: CGFloat
258 | let maxMagnification: CGFloat
259 | let zoomStep: CGFloat
260 |
261 | private let zoomLevels: [CGFloat] = [1.0, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0]
262 |
263 | var body: some View {
264 | HStack(spacing: 8) {
265 | // Zoom out button
266 | ZoomButton(
267 | icon: "minus.magnifyingglass",
268 | isEnabled: magnification > minMagnification,
269 | isHovered: hoveredButton == .zoomOut
270 | ) {
271 | hoveredButton = .zoomOut
272 | } onExit: {
273 | hoveredButton = nil
274 | } action: {
275 | let newMagnification = max(magnification - zoomStep, minMagnification)
276 | withAnimation(.spring(response: 0.2, dampingFraction: 0.7)) {
277 | magnification = newMagnification
278 | lastMagnification = newMagnification
279 | if newMagnification == 1.0 {
280 | offset = .zero
281 | lastOffset = .zero
282 | }
283 | }
284 | }
285 |
286 | // Percentage display and selector
287 | Menu {
288 | ForEach(zoomLevels, id: \.self) { level in
289 | Button {
290 | withAnimation(.spring(response: 0.2, dampingFraction: 0.7)) {
291 | magnification = level
292 | lastMagnification = level
293 | if level == 1.0 {
294 | offset = .zero
295 | lastOffset = .zero
296 | }
297 | }
298 | } label: {
299 | HStack {
300 | Text("\(Int(level * 100))%")
301 | if magnification == level {
302 | Image(systemName: "checkmark")
303 | }
304 | }
305 | }
306 | }
307 | } label: {
308 | Text("\(Int(magnification * 100))%")
309 | .font(.caption)
310 | .fontWeight(.medium)
311 | .fontDesign(.monospaced)
312 | .padding(.horizontal, 8)
313 | .padding(.vertical, 6)
314 | .background(
315 | RoundedRectangle(cornerRadius: 6)
316 | .fill(.background.opacity(0.7))
317 | )
318 | .foregroundStyle(.primary)
319 | }
320 | .menuStyle(.borderlessButton)
321 | .buttonStyle(.plain)
322 |
323 | // Zoom in button
324 | ZoomButton(
325 | icon: "plus.magnifyingglass",
326 | isEnabled: magnification < maxMagnification,
327 | isHovered: hoveredButton == .zoomIn
328 | ) {
329 | hoveredButton = .zoomIn
330 | } onExit: {
331 | hoveredButton = nil
332 | } action: {
333 | let newMagnification = min(magnification + zoomStep, maxMagnification)
334 | withAnimation(.spring(response: 0.2, dampingFraction: 0.7)) {
335 | magnification = newMagnification
336 | lastMagnification = newMagnification
337 | }
338 | }
339 | }
340 | .padding(6)
341 | .background(
342 | RoundedRectangle(cornerRadius: 8)
343 | .fill(.background.opacity(0.8))
344 | .shadow(color: .black.opacity(0.15), radius: 1, x: 0, y: 0.4)
345 | )
346 | }
347 | }
348 |
349 | struct ZoomButton: View {
350 | let icon: String
351 | let isEnabled: Bool
352 | let isHovered: Bool
353 | let onHover: () -> Void
354 | let onExit: () -> Void
355 | let action: () -> Void
356 |
357 | init(
358 | icon: String,
359 | isEnabled: Bool,
360 | isHovered: Bool,
361 | onHover: @escaping () -> Void,
362 | onExit: @escaping () -> Void,
363 | action: @escaping () -> Void
364 | ) {
365 | self.icon = icon
366 | self.isEnabled = isEnabled
367 | self.isHovered = isHovered
368 | self.onHover = onHover
369 | self.onExit = onExit
370 | self.action = action
371 | }
372 |
373 | var body: some View {
374 | Button(action: action) {
375 | Image(systemName: icon)
376 | .frame(width: 20, height: 20)
377 | .background(
378 | RoundedRectangle(cornerRadius: 6)
379 | .fill(.background.opacity(isHovered ? 0.9 : 0.6))
380 | )
381 | .scaleEffect(isHovered ? 1.1 : 1.0)
382 | .foregroundStyle(isEnabled ? .primary : Color.secondary.opacity(0.5))
383 | }
384 | .buttonStyle(.plain)
385 | .disabled(!isEnabled)
386 | .onHover { hovering in
387 | if hovering {
388 | onHover()
389 | } else {
390 | onExit()
391 | }
392 | withAnimation(.spring(response: 0.3, dampingFraction: 0.6)) {
393 | // Animation handled by isHovered binding
394 | }
395 | }
396 | }
397 | }
398 |
--------------------------------------------------------------------------------
/HiPixel/Services/ResourceDownloadManager.swift:
--------------------------------------------------------------------------------
1 | //
2 | // ResourceDownloadManager.swift
3 | // HiPixel
4 | //
5 | // Created by 十里 on 2025/7/28.
6 | //
7 |
8 | import Foundation
9 | import CryptoKit
10 | import SwiftUI
11 |
12 | @MainActor
13 | class ResourceDownloadManager: NSObject, ObservableObject {
14 | static let shared = ResourceDownloadManager()
15 |
16 | @Published var downloadState: DownloadState = .idle
17 | @Published var downloadProgress: Double = 0
18 | @Published var downloadSpeed: String = ""
19 | @Published var currentVersion: String = ""
20 | @Published var remoteVersion: String = ""
21 | @Published var errorMessage: String = ""
22 |
23 | private let fileManager = FileManager.default
24 | private var downloadTask: URLSessionDownloadTask?
25 |
26 | enum DownloadState: Equatable, CustomStringConvertible {
27 | case idle
28 | case checking
29 | case downloading(String) // resource name
30 | case installing
31 | case completed
32 | case error(String)
33 |
34 | var description: String {
35 | switch self {
36 | case .idle:
37 | return "idle"
38 | case .checking:
39 | return "checking"
40 | case .downloading(let resource):
41 | return "downloading(\(resource))"
42 | case .installing:
43 | return "installing"
44 | case .completed:
45 | return "completed"
46 | case .error(let message):
47 | return "error(\(message))"
48 | }
49 | }
50 | }
51 |
52 | private override init() {
53 | super.init()
54 | loadCurrentVersion()
55 | checkResourcesExist()
56 | }
57 |
58 | // MARK: - Public Methods
59 |
60 | func checkForUpdates() async {
61 | // Prevent multiple concurrent downloads
62 | switch downloadState {
63 | case .checking, .downloading(_), .installing:
64 | Common.logger.info("Download already in progress, skipping checkForUpdates")
65 | return
66 | default:
67 | break
68 | }
69 |
70 | downloadState = .checking
71 |
72 | do {
73 | let toolcastInfo = try await ToolcastInfo.fetch()
74 | remoteVersion = toolcastInfo.version
75 |
76 | if needsUpdate(remote: toolcastInfo.version) {
77 | await downloadResources(toolcastInfo: toolcastInfo)
78 | } else {
79 | downloadState = .completed
80 | }
81 | } catch {
82 | downloadState = .error(error.localizedDescription)
83 | errorMessage = error.localizedDescription
84 | Common.logger.error("Failed to check for updates: \(error)")
85 | }
86 | }
87 |
88 | func downloadResourcesIfNeeded() async {
89 | // Prevent multiple concurrent downloads
90 | switch downloadState {
91 | case .checking, .downloading(_), .installing:
92 | Common.logger.info("Download already in progress, skipping downloadResourcesIfNeeded")
93 | return
94 | default:
95 | break
96 | }
97 |
98 | // First check if resources exist
99 | checkResourcesExist()
100 |
101 | let binExists = fileManager.fileExists(atPath: binPath.path) &&
102 | fileManager.fileExists(atPath: binPath.appendingPathComponent("upscayl-bin").path)
103 | let modelsExists = fileManager.fileExists(atPath: modelsPath.path) &&
104 | hasModelFiles() // Check if models directory has content
105 |
106 | if !binExists || !modelsExists {
107 | Common.logger.info("Resources missing - bin exists: \(binExists), models exists: \(modelsExists)")
108 | await checkForUpdates()
109 | } else {
110 | // Just check for updates without forcing download
111 | downloadState = .checking
112 | do {
113 | let toolcastInfo = try await ToolcastInfo.fetch()
114 | remoteVersion = toolcastInfo.version
115 |
116 | if needsUpdate(remote: toolcastInfo.version) {
117 | Common.logger.info("Update available: \(self.currentVersion) -> \(self.remoteVersion)")
118 | await downloadResources(toolcastInfo: toolcastInfo)
119 | } else {
120 | downloadState = .completed
121 | }
122 | } catch {
123 | // If we can't check for updates but have local resources, continue
124 | downloadState = .completed
125 | Common.logger.error("Failed to check for updates, using local resources: \(error)")
126 | }
127 | }
128 | }
129 |
130 | // MARK: - Private Methods
131 |
132 | private func downloadResources(toolcastInfo: ToolcastInfo) async {
133 | do {
134 | // Download bin.zip
135 | downloadState = .downloading("bin")
136 | let binZipPath = try await downloadFile(url: toolcastInfo.bin.url, expectedSHA256: toolcastInfo.bin.sha256)
137 |
138 | // Download models.zip
139 | downloadState = .downloading("models")
140 | let modelsZipPath = try await downloadFile(url: toolcastInfo.models.url, expectedSHA256: toolcastInfo.models.sha256)
141 |
142 | // Install resources
143 | downloadState = .installing
144 | try await installResources(binZip: binZipPath, modelsZip: modelsZipPath, version: toolcastInfo.version)
145 |
146 | // Clean up
147 | try fileManager.removeItem(at: binZipPath)
148 | try fileManager.removeItem(at: modelsZipPath)
149 |
150 | downloadState = .completed
151 | currentVersion = toolcastInfo.version
152 |
153 | } catch {
154 | downloadState = .error(error.localizedDescription)
155 | errorMessage = error.localizedDescription
156 | Common.logger.error("Failed to download resources: \(error)")
157 | }
158 | }
159 |
160 | private func downloadFile(url: String, expectedSHA256: String) async throws -> URL {
161 | guard let downloadURL = URL(string: url) else {
162 | throw ResourceError.invalidURL
163 | }
164 |
165 | let tempURL = Common.directory.appendingPathComponent(UUID().uuidString + ".zip")
166 |
167 | return try await withCheckedThrowingContinuation { continuation in
168 | downloadTask = URLSession.shared.downloadTask(with: downloadURL) { [weak self] localURL, response, error in
169 | Task { @MainActor in
170 | if let error = error {
171 | continuation.resume(throwing: error)
172 | return
173 | }
174 |
175 | guard let localURL = localURL else {
176 | continuation.resume(throwing: ResourceError.downloadFailed)
177 | return
178 | }
179 |
180 | do {
181 | // Move to temp location
182 | try self?.fileManager.moveItem(at: localURL, to: tempURL)
183 |
184 | // Verify SHA256
185 | let actualSHA256 = try self?.calculateSHA256(url: tempURL) ?? ""
186 | guard actualSHA256 == expectedSHA256 else {
187 | try? self?.fileManager.removeItem(at: tempURL)
188 | continuation.resume(throwing: ResourceError.checksumMismatch)
189 | return
190 | }
191 |
192 | continuation.resume(returning: tempURL)
193 | } catch {
194 | continuation.resume(throwing: error)
195 | }
196 | }
197 | }
198 |
199 | // Add progress tracking
200 | downloadTask?.progress.addObserver(self as NSObject, forKeyPath: "fractionCompleted", options: .new, context: nil)
201 | downloadTask?.resume()
202 | }
203 | }
204 |
205 | private func installResources(binZip: URL, modelsZip: URL, version: String) async throws {
206 | // Backup existing resources
207 | let backupDir = Common.directory.appendingPathComponent("backup")
208 | try? fileManager.createDirectory(at: backupDir, withIntermediateDirectories: true, attributes: nil)
209 |
210 | // Backup bin
211 | if fileManager.fileExists(atPath: binPath.path) {
212 | let binBackup = backupDir.appendingPathComponent("bin")
213 | try? fileManager.removeItem(at: binBackup)
214 | try? fileManager.moveItem(at: binPath, to: binBackup)
215 | }
216 |
217 | // Backup models
218 | if fileManager.fileExists(atPath: modelsPath.path) {
219 | let modelsBackup = backupDir.appendingPathComponent("models")
220 | try? fileManager.removeItem(at: modelsBackup)
221 | try? fileManager.moveItem(at: modelsPath, to: modelsBackup)
222 | }
223 |
224 | do {
225 | // Unzip bin
226 | try await unzip(file: binZip, to: Common.directory)
227 |
228 | // Unzip models
229 | try await unzip(file: modelsZip, to: Common.directory)
230 |
231 | // Make bin executable
232 | try fileManager.setAttributes([.posixPermissions: 0o755], ofItemAtPath: binPath.appendingPathComponent("upscayl-bin").path)
233 |
234 | // Save version
235 | try version.write(to: versionFilePath, atomically: true, encoding: .utf8)
236 |
237 | // Remove backup
238 | try? fileManager.removeItem(at: backupDir)
239 |
240 | } catch {
241 | // Restore backup on failure
242 | try? fileManager.removeItem(at: binPath)
243 | try? fileManager.removeItem(at: modelsPath)
244 |
245 | let binBackup = backupDir.appendingPathComponent("bin")
246 | let modelsBackup = backupDir.appendingPathComponent("models")
247 |
248 | try? fileManager.moveItem(at: binBackup, to: binPath)
249 | try? fileManager.moveItem(at: modelsBackup, to: modelsPath)
250 |
251 | throw error
252 | }
253 | }
254 |
255 | private func unzip(file: URL, to destination: URL) async throws {
256 | return try await withCheckedThrowingContinuation { continuation in
257 | let process = Process()
258 | process.executableURL = URL(fileURLWithPath: "/usr/bin/unzip")
259 | process.arguments = ["-o", file.path, "-d", destination.path]
260 |
261 | do {
262 | try process.run()
263 | process.terminationHandler = { process in
264 | if process.terminationStatus == 0 {
265 | continuation.resume()
266 | } else {
267 | continuation.resume(throwing: ResourceError.unzipFailed)
268 | }
269 | }
270 | } catch {
271 | continuation.resume(throwing: error)
272 | }
273 | }
274 | }
275 |
276 | private func calculateSHA256(url: URL) throws -> String {
277 | let data = try Data(contentsOf: url)
278 | let hash = SHA256.hash(data: data)
279 | return hash.compactMap { String(format: "%02x", $0) }.joined()
280 | }
281 |
282 | private func needsUpdate(remote: String) -> Bool {
283 | return currentVersion != remote
284 | }
285 |
286 | private func loadCurrentVersion() {
287 | if let version = try? String(contentsOf: versionFilePath, encoding: .utf8) {
288 | currentVersion = version.trimmingCharacters(in: .whitespacesAndNewlines)
289 | } else {
290 | // No version file found, set as empty for now
291 | currentVersion = ""
292 | }
293 | }
294 |
295 | private func checkResourcesExist() {
296 | let binExists = fileManager.fileExists(atPath: binPath.path) &&
297 | fileManager.fileExists(atPath: binPath.appendingPathComponent("upscayl-bin").path)
298 | let modelsExists = fileManager.fileExists(atPath: modelsPath.path) && hasModelFiles()
299 |
300 | Common.logger.info("Resources check: bin=\(binExists), models=\(modelsExists), currentVersion='\(self.currentVersion)'")
301 |
302 | if !binExists || !modelsExists {
303 | downloadState = .idle
304 | currentVersion = "Not installed"
305 | Common.logger.info("Resources missing - setting currentVersion to 'Not installed'")
306 | } else if currentVersion.isEmpty || currentVersion == "Not installed" {
307 | // Resources exist but no version info, we still need to check for updates
308 | downloadState = .idle
309 | currentVersion = "Unknown"
310 | Common.logger.info("Resources exist but version unknown")
311 | } else {
312 | downloadState = .completed
313 | Common.logger.info("Resources exist with version: \(self.currentVersion)")
314 | }
315 | }
316 |
317 | private func hasModelFiles() -> Bool {
318 | do {
319 | let contents = try fileManager.contentsOfDirectory(atPath: modelsPath.path)
320 | return !contents.isEmpty && contents.contains { $0.hasSuffix(".bin") || $0.hasSuffix(".param") }
321 | } catch {
322 | return false
323 | }
324 | }
325 |
326 | // MARK: - Progress Observation
327 |
328 | override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
329 | if keyPath == "fractionCompleted" {
330 | Task { @MainActor in
331 | if let progress = downloadTask?.progress {
332 | downloadProgress = progress.fractionCompleted
333 |
334 | // Calculate download speed
335 | let bytesReceived = progress.completedUnitCount
336 | let timeElapsed = progress.estimatedTimeRemaining ?? 0
337 |
338 | if timeElapsed > 0 {
339 | let speed = Double(bytesReceived) / timeElapsed
340 | downloadSpeed = ByteCountFormatter().string(fromByteCount: Int64(speed)) + "/s"
341 | }
342 | }
343 | }
344 | }
345 | }
346 |
347 | // MARK: - Helper Properties
348 |
349 | private var binPath: URL {
350 | Common.directory.appendingPathComponent("bin")
351 | }
352 |
353 | private var modelsPath: URL {
354 | Common.directory.appendingPathComponent("models")
355 | }
356 |
357 | private var versionFilePath: URL {
358 | Common.directory.appendingPathComponent("version.txt")
359 | }
360 | }
361 |
362 | // MARK: - ResourceError
363 | enum ResourceError: LocalizedError {
364 | case invalidURL
365 | case downloadFailed
366 | case checksumMismatch
367 | case unzipFailed
368 |
369 | var errorDescription: String? {
370 | switch self {
371 | case .invalidURL:
372 | return "Invalid download URL"
373 | case .downloadFailed:
374 | return "Download failed"
375 | case .checksumMismatch:
376 | return "File checksum verification failed"
377 | case .unzipFailed:
378 | return "Failed to extract files"
379 | }
380 | }
381 | }
382 |
--------------------------------------------------------------------------------
More ways to support
225 | 226 | - 🛍️ **[One-time Support via LemonSqueezy](https://okooo5km.lemonsqueezy.com/buy/4f1e3249-2683-4000-acd4-6b05ae117b40?discount=0)** 227 | 228 | - **WeChat Pay** 229 | 230 |
231 |
232 |
237 |
238 |