[removeExtensions]: Refactored AppManager and moved out removeAppExtensions to fix subtle logic bugs

AltStore/Operations/RemoveAppExtensionsOperation.swift

@@ -0,0 +1,182 @@
+//
+//  RefreshAppOperation.swift
+//  AltStore
+//
+//  Created by Riley Testut on 2/27/20.
+//  Copyright © 2020 Riley Testut. All rights reserved.
+//
+
+import Foundation
+
+import AltStoreCore
+import Roxas
+import AltSign
+
+@objc(RemoveAppExtensionsOperation)
+final class RemoveAppExtensionsOperation: ResultOperation<Void>
+{
+    let context: AppOperationContext
+    let appInDatabase: AppProtocol
+    
+    init(context: AppOperationContext, appInDatabase: AppProtocol)
+    {
+        self.context = context
+        self.appInDatabase = appInDatabase
+        super.init()
+    }
+    
+    override func main()
+    {
+        super.main()
+        
+        if let error = self.context.error
+        {
+            self.finish(.failure(error))
+            return
+        }
+        
+        guard let targetAppBundle = context.app else {
+            return self.finish(.failure(
+                OperationError.invalidParameters("RemoveAppExtensionsOperation: context.app is nil")
+            ))
+        }
+        
+        self.removeAppExtensions(from: targetAppBundle,
+                                  appInDatabase: appInDatabase as? InstalledApp,
+                                  extensions: targetAppBundle.appExtensions,
+                                  context.authenticatedContext.presentingViewController)
+        
+    }
+    
+    
+    private static func removeExtensions(from extensions: Set<ALTApplication>) throws {
+        for appExtension in extensions {
+            print("Deleting extension \(appExtension.bundleIdentifier)")
+            try FileManager.default.removeItem(at: appExtension.fileURL)
+        }
+    }
+                                  
+    
+    
+    private func removeAppExtensions(from targetAppBundle: ALTApplication,
+                             appInDatabase: InstalledApp?,
+                             extensions: Set<ALTApplication>,
+                             _ presentingViewController: UIViewController?)
+    {
+            
+        // target App Bundle doesn't contain extensions so don't bother
+        guard !targetAppBundle.appExtensions.isEmpty else {
+            return self.finish(.success(()))
+        }
+        
+        //App-Extensions: Ensure existing app's extensions in DB and currently installing app bundle's extensions must match
+        let existingAppEx: Set<InstalledExtension> = appInDatabase?.appExtensions ?? Set()
+        let targetAppEx: Set<ALTApplication> = targetAppBundle.appExtensions
+        
+        let existingAppExNames = existingAppEx.map{ appEx in appEx.bundleIdentifier}
+        let targetAppExNames  = targetAppEx.map{ appEx in appEx.bundleIdentifier}
+        
+        let excessExtensionsInTargetApp = targetAppEx.filter{
+            !(existingAppExNames.contains($0.bundleIdentifier))
+        }
+        
+        let necessaryExtensionsInExistingApp = existingAppEx.filter{
+            targetAppExNames.contains($0.bundleIdentifier)
+        }
+        
+        // always cleanup existing app (app-in-db) based on incoming app that is targeted for install
+        appInDatabase?.appExtensions = necessaryExtensionsInExistingApp
+        
+        let isMatching = (targetAppEx.count == existingAppEx.count) && excessExtensionsInTargetApp.isEmpty
+        let diagnosticsMsg = "RemoveAppExtensionsOperation: App Extensions in existingApp and targetAppBundle are matching: \(isMatching)\n"
+                           + "RemoveAppExtensionsOperation: existingAppEx: \(existingAppExNames); targetAppBundleEx: \(String(describing: targetAppExNames))\n"
+        print(diagnosticsMsg)
+     
+        // if background mode, then remove only the excess extensions
+        guard let presentingViewController: UIViewController = presentingViewController else {
+            // perform silent extensions cleanup for those that aren't already present in existing app
+            print("\n    Performing background mode Extensions removal    \n")
+            print("RemoveAppExtensionsOperation: Excess Extensions In TargetAppBundle: \(excessExtensionsInTargetApp)")
+            print("RemoveAppExtensionsOperation: Necessary Extensions In ExistingAppInDatabase: \(necessaryExtensionsInExistingApp)")
+            
+            do {
+                try Self.removeExtensions(from: excessExtensionsInTargetApp)
+                return self.finish(.success(()))
+            } catch {
+                return self.finish(.failure(error))
+            }
+        }
+
+        
+        
+        
+        let firstSentence: String
+        
+        if UserDefaults.standard.activeAppLimitIncludesExtensions
+        {
+            firstSentence = NSLocalizedString("Non-developer Apple IDs are limited to 3 active apps and app extensions.", comment: "")
+        }
+        else
+        {
+            firstSentence = NSLocalizedString("Non-developer Apple IDs are limited to creating 10 App IDs per week.", comment: "")
+        }
+        
+        let message = firstSentence + " " + NSLocalizedString("Would you like to remove this app's extensions so they don't count towards your limit? There are \(extensions.count) Extensions", comment: "")
+        
+        
+        
+        let alertController = UIAlertController(title: NSLocalizedString("App Contains Extensions", comment: ""), message: message, preferredStyle: .alert)
+        alertController.addAction(UIAlertAction(title: UIAlertAction.cancel.title, style: UIAlertAction.cancel.style, handler: { (action) in
+            self.finish(.failure(OperationError.cancelled))
+        }))
+        alertController.addAction(UIAlertAction(title: NSLocalizedString("Keep App Extensions", comment: ""), style: .default) { (action) in
+            self.finish(.success(()))
+        })
+        alertController.addAction(UIAlertAction(title: NSLocalizedString("Remove App Extensions", comment: ""), style: .destructive) { (action) in
+            do {
+                try Self.removeExtensions(from: targetAppBundle.appExtensions)
+                return self.finish(.success(()))
+            } catch {
+                return self.finish(.failure(error))
+            }
+        })
+        
+        
+        
+        alertController.addAction(UIAlertAction(title: NSLocalizedString("Choose App Extensions", comment: ""), style: .default) { (action) in
+
+            
+            let popoverContentController = AppExtensionViewHostingController(extensions: extensions) { (selection) in
+                do {
+                    try Self.removeExtensions(from: Set(selection))
+                    return self.finish(.success(()))
+                } catch {
+                    return self.finish(.failure(error))
+                }
+            }
+            
+            let suiview = popoverContentController.view!
+            suiview.translatesAutoresizingMaskIntoConstraints = false
+            
+            popoverContentController.modalPresentationStyle = .popover
+            
+            if let popoverPresentationController = popoverContentController.popoverPresentationController {
+                popoverPresentationController.sourceView = presentingViewController.view
+                popoverPresentationController.sourceRect = CGRect(x: 50, y: 50, width: 4, height: 4)
+                popoverPresentationController.delegate = popoverContentController
+                
+                DispatchQueue.main.async {
+                    presentingViewController.present(popoverContentController, animated: true)
+                }
+            }else{
+                self.finish(.failure(
+                    OperationError.invalidParameters("RemoveAppExtensionsOperation: popoverContentController.popoverPresentationController is nil"))
+                )
+            }
+        })
+        
+        DispatchQueue.main.async {
+            presentingViewController.present(alertController, animated: true)
+        }
+    }
+}