Verifies min/max OS version before downloading app + asks user to download older app version if necessary

AltStore/Operations/DownloadAppOperation.swift

@@ -17,46 +17,104 @@ final class DownloadAppOperation: ResultOperation<ALTApplication>
 {
     let app: AppProtocol
     let context: AppOperationContext
-    
+
     private let appName: String
     private let bundleIdentifier: String
-    private var sourceURL: URL?
     private let destinationURL: URL
-    
+
     private let session = URLSession(configuration: .default)
     private let temporaryDirectory = FileManager.default.uniqueTemporaryURL()
-    
+
     init(app: AppProtocol, destinationURL: URL, context: AppOperationContext)
     {
         self.app = app
         self.context = context
-        
+
         self.appName = app.name
         self.bundleIdentifier = app.bundleIdentifier
         self.sourceURL = app.url
         self.destinationURL = destinationURL
-        
+
         super.init()
-        
+
         // App = 3, Dependencies = 1
         self.progress.totalUnitCount = 4
     }
-    
+
     override func main()
     {
         super.main()
-        
+
         if let error = self.context.error
         {
             self.finish(.failure(error))
             return
         }
-        
-        print("Downloading App:", self.bundleIdentifier)
-        
-        guard let sourceURL = self.sourceURL else { return self.finish(.failure(OperationError.appNotFound(name: self.appName))) }
 
-        self.downloadApp(from: sourceURL) { result in
+        print("Downloading App:", self.bundleIdentifier)
+
+        self.localizedFailure = String(format: NSLocalizedString("%@ could not be downloaded.", comment: ""), self.appName)
+
+        guard let storeApp = self.app as? StoreApp else { return self.download(self.app) }
+        storeApp.managedObjectContext?.perform {
+            do {
+                let latestVersion = try self.verify(storeApp)
+                self.download(latestVersion)
+            } catch let error as VerificationError where error.code == .iOSVersionNotSupported {
+                guard let presentingViewController = self.context.presentingViewController,
+                      let latestSupportedVersion = storeApp.latestSupportedVersion,
+                      case let version = latestSupportedVersion.version,
+                      version != storeApp.installedApp?.version else {
+                    return self.finish(.failure(error))
+                }
+                let title = NSLocalizedString("Unsupported iOS Version", comment: "")
+                let message = error.localizedDescription + "\n\n" + NSLocalizedString("Would you like to download the last version compatible with this device instead?", comment: "")
+
+                DispatchQueue.main.async {
+                    let alertController = UIAlertController(title: title, message: message, preferredStyle: .alert)
+                    alertController.addAction(UIAlertAction(title: UIAlertAction.cancel.title, style: UIAlertAction.cancel.style) { _ in
+                        self.finish(.failure(OperationError.cancelled))
+                    })
+                    alertController.addAction(UIAlertAction(title: String(format: NSLocalizedString("Download %@ %@", comment: ""), self.appName, version), style: .default) { _ in
+                        self.download(latestSupportedVersion)
+                    })
+                    presentingViewController.present(alertController, animated: true)
+                }
+            } catch {
+                self.finish(.failure(error))
+            }
+        }
+    }
+
+    override func finish(_ result: Result<ALTApplication, any Error>) {
+        do {
+            try FileManager.default.removeItem(at: self.temporaryDirectory)
+        } catch {
+            print("Failed to remove DownloadAppOperation temporary directory: \(self.temporaryDirectory).", error)
+        }
+        super.finish(result)
+    }
+}
+
+private extension DownloadAppOperation {
+    func verify(_ storeApp: StoreApp) throws -> AppVersion {
+        guard let version = storeApp.latestAvailableVersion else {
+            let failureReason = String(format: NSLocalizedString("The latest version of %@ could not be determined.", comment: ""), self.appName)
+            throw OperationError.unknown(failureReason: failureReason)
+        }
+        if let minOSVersion = version.minOSVersion, !ProcessInfo.processInfo.isOperatingSystemAtLeast(minOSVersion) {
+            throw VerificationError.iOSVersionNotSupported(app: storeApp, requiredOSVersion: minOSVersion)
+        } else if let maxOSVersion = version.maxOSVersion, ProcessInfo.processInfo.operatingSystemVersion > maxOSVersion {
+            throw VerificationError.iOSVersionNotSupported(app: storeApp, requiredOSVersion: maxOSVersion)
+        }
+
+        return version
+    }
+
+    func download(@Managed _ app: AppProtocol) {
+        guard let sourceURL = $app.url else { return self.finish(.failure(OperationError.appNotFound(name: self.appName))) }
+
+        self.downloadIPA(from: sourceURL) { result in
             do
             {
                 let application = try result.get()
@@ -97,24 +155,7 @@ final class DownloadAppOperation: ResultOperation<ALTApplication>
         }
     }
     
-    override func finish(_ result: Result<ALTApplication, Error>)
-    {
-        do
-        {
-            try FileManager.default.removeItem(at: self.temporaryDirectory)
-        }
-        catch
-        {
-            print("Failed to remove DownloadAppOperation temporary directory: \(self.temporaryDirectory).", error)
-        }
-        
-        super.finish(result)
-    }
-}
-
-private extension DownloadAppOperation
-{
-    func downloadApp(from sourceURL: URL, completionHandler: @escaping (Result<ALTApplication, Error>) -> Void)
+    func downloadIPA(from sourceURL: URL, completionHandler: @escaping (Result<ALTApplication, Error>) -> Void)
     {
         func finishOperation(_ result: Result<URL, Error>)
         {

AltStore/Operations/VerifyAppOperation.swift

@@ -30,7 +30,7 @@ extension VerificationError
         VerificationError(code: .mismatchedBundleIdentifiers, app: app, sourceBundleID: sourceBundleID)
     }
 
-    static func iOSVersionNotSupported(app: ALTApplication) -> VerificationError {
+    static func iOSVersionNotSupported(app: ALTApplication, osVersion: OperatingSystemVersion = ProcessInfo.processInfo.operatingSystemVersion, requiredOSVersion: OperatingSystemVersion?) -> VerificationError {
         VerificationError(code: .iOSVersionNotSupported, app: app)
     }
 }
@@ -41,38 +41,54 @@ struct VerificationError: ALTLocalizedError {
     var errorTitle: String?
     var errorFailure: String?
 
-    var app: ALTApplication?
+    @Managed var app: AppProtocol?
     var entitlements: [String: Any]?
     var sourceBundleID: String?
+    var deviceOSVersion: OperatingSystemVersion?
+    var requiredOSVersion: OperatingSystemVersion?
+    
+    var errorDescription: String? {
+        switch self.code {
+        case .iOSVersionNotSupported:
+            guard let deviceOSVersion else { return nil }
+
+            var failureReason = self.errorFailureReason
+            if self.app == nil {
+                let firstLetter = failureReason.prefix(1).lowercased()
+                failureReason = firstLetter + failureReason.dropFirst()
+            }
+
+            return String(formatted: "This device is running iOS %@, but %@", deviceOSVersion.stringValue, failureReason)
+        default: return nil
+        }
+    }
 
     var errorFailureReason: String {
         switch self.code
         {
         case .privateEntitlements:
-            let appName = (self.app?.name as String?).map { String(format: NSLocalizedString("'%@'", comment: ""), $0) } ??
-            	NSLocalizedString("Unknown app", comment: "")
-            return String(format: NSLocalizedString("“%@” requires private permissions.", comment: ""), appName)
+            let appName = self.$app.name ?? NSLocalizedString("The app", comment: "")
+            return String(formatted: "“%@” requires private permissions.", appName)
 
         case .mismatchedBundleIdentifiers:
-            if let app, let sourceBundleID {
-                return String(format: NSLocalizedString("The bundle ID '%@' does not match the one specified by the source ('%@').", comment: ""), app.bundleIdentifier, sourceBundleID)
+            if let appBundleID = self.$app.bundleIdentifier, let bundleID = self.sourceBundleID {
+                return String(formatted: "The bundle ID '%@' does not match the one specified by the source ('%@').", appBundleID, bundleID)
             } else {
                 return NSLocalizedString("The bundle ID does not match the one specified by the source.", comment: "")
             }
 
         case .iOSVersionNotSupported:
-            var failureReason: String!
-            if let app {
-                var version = "iOS \(app.minimumiOSVersion.majorVersion).\(app.minimumiOSVersion.minorVersion)"
-                if app.minimumiOSVersion.patchVersion > 0 {
-                    version += ".\(app.minimumiOSVersion.patchVersion)"
-                }
-                failureReason = String(format: NSLocalizedString("%@ requires %@.", comment: ""), app.name, version)
-            } else {
-                let version = ProcessInfo.processInfo.operatingSystemVersionString
-                failureReason = String(format: NSLocalizedString("This app does not support iOS %@.", comment: ""), version)
+            let appName = self.$app.name ?? NSLocalizedString("The app", comment: "")
+            let deviceOSVersion = self.deviceOSVersion ?? ProcessInfo.processInfo.operatingSystemVersion
+
+            guard let requiredOSVersion else {
+                return String(formatted: "%@ does not support iOS %@.", appName, deviceOSVersion.stringValue)
+            }
+            if deviceOSVersion > requiredOSVersion {
+                return String(formatted: "%@ requires iOS %@ or earlier", appName, requiredOSVersion.stringValue)
+            } else {
+                return String(formatted: "%@ requires iOS %@ or later", appName, requiredOSVersion.stringValue)
             }
-            return failureReason
         }
     }
 }
@@ -108,7 +124,7 @@ final class VerifyAppOperation: ResultOperation<Void>
             }
             
             guard ProcessInfo.processInfo.isOperatingSystemAtLeast(app.minimumiOSVersion) else {
-                throw VerificationError.iOSVersionNotSupported(app: app)
+                throw VerificationError.iOSVersionNotSupported(app: app, requiredOSVersion: app.minimumiOSVersion)
             }
             
             if #available(iOS 13.5, *)
@@ -190,8 +206,7 @@ private extension VerifyAppOperation
                 }))
                 presentingViewController.present(alertController, animated: true, completion: nil)
                 
-            case .mismatchedBundleIdentifiers: return completion(.failure(error))
-            case .iOSVersionNotSupported: return completion(.failure(error))
+            case .mismatchedBundleIdentifiers, .iOSVersionNotSupported: return completion(.failure(error))
             }
         }
     }