diff --git a/AltKit/AltKit.h b/AltKit/AltKit.h index 759128e5..7d1b7380 100644 --- a/AltKit/AltKit.h +++ b/AltKit/AltKit.h @@ -7,3 +7,6 @@ // #import "NSError+ALTServerError.h" +#import "CFNotificationName+AltStore.h" + +extern uint16_t ALTDeviceListeningSocket; diff --git a/AltKit/AltKit.m b/AltKit/AltKit.m new file mode 100644 index 00000000..1e97d6b7 --- /dev/null +++ b/AltKit/AltKit.m @@ -0,0 +1,11 @@ +// +// AltKit.m +// AltKit +// +// Created by Riley Testut on 1/10/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +#import + +uint16_t ALTDeviceListeningSocket = 28151; diff --git a/AltKit/Bundle+AltStore.swift b/AltKit/Bundle+AltStore.swift index d5802cd4..90f065b7 100644 --- a/AltKit/Bundle+AltStore.swift +++ b/AltKit/Bundle+AltStore.swift @@ -14,9 +14,11 @@ public extension Bundle { public static let deviceID = "ALTDeviceID" public static let serverID = "ALTServerID" + public static let certificateID = "ALTCertificateID" public static let appGroups = "ALTAppGroups" public static let urlTypes = "CFBundleURLTypes" + public static let exportedUTIs = "UTExportedTypeDeclarations" } } @@ -26,4 +28,9 @@ public extension Bundle let infoPlistURL = self.bundleURL.appendingPathComponent("Info.plist") return infoPlistURL } + + var certificateURL: URL { + let infoPlistURL = self.bundleURL.appendingPathComponent("ALTCertificate.p12") + return infoPlistURL + } } diff --git a/AltKit/CFNotificationName+AltStore.h b/AltKit/CFNotificationName+AltStore.h new file mode 100644 index 00000000..01c2a336 --- /dev/null +++ b/AltKit/CFNotificationName+AltStore.h @@ -0,0 +1,17 @@ +// +// CFNotificationName+AltStore.h +// AltKit +// +// Created by Riley Testut on 1/10/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +#import + +NS_ASSUME_NONNULL_BEGIN + +extern CFNotificationName const ALTWiredServerConnectionAvailableRequest NS_SWIFT_NAME(wiredServerConnectionAvailableRequest); +extern CFNotificationName const ALTWiredServerConnectionAvailableResponse NS_SWIFT_NAME(wiredServerConnectionAvailableResponse); +extern CFNotificationName const ALTWiredServerConnectionStartRequest NS_SWIFT_NAME(wiredServerConnectionStartRequest); + +NS_ASSUME_NONNULL_END diff --git a/AltKit/CFNotificationName+AltStore.m b/AltKit/CFNotificationName+AltStore.m new file mode 100644 index 00000000..ac0eb5d1 --- /dev/null +++ b/AltKit/CFNotificationName+AltStore.m @@ -0,0 +1,13 @@ +// +// CFNotificationName+AltStore.m +// AltKit +// +// Created by Riley Testut on 1/10/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +#import "CFNotificationName+AltStore.h" + +CFNotificationName const ALTWiredServerConnectionAvailableRequest = CFSTR("io.altstore.Request.WiredServerConnectionAvailable"); +CFNotificationName const ALTWiredServerConnectionAvailableResponse = CFSTR("io.altstore.Response.WiredServerConnectionAvailable"); +CFNotificationName const ALTWiredServerConnectionStartRequest = CFSTR("io.altstore.Request.WiredServerConnectionStart"); diff --git a/AltKit/NSError+ALTServerError.h b/AltKit/NSError+ALTServerError.h index f1d5c9c1..bb9176ae 100644 --- a/AltKit/NSError+ALTServerError.h +++ b/AltKit/NSError+ALTServerError.h @@ -27,6 +27,12 @@ typedef NS_ERROR_ENUM(AltServerErrorDomain, ALTServerError) ALTServerErrorInstallationFailed = 8, ALTServerErrorMaximumFreeAppLimitReached = 9, ALTServerErrorUnsupportediOSVersion = 10, + + ALTServerErrorUnknownRequest = 11, + ALTServerErrorUnknownResponse = 12, + + ALTServerErrorInvalidAnisetteData = 13, + ALTServerErrorPluginNotFound = 14 }; NS_ASSUME_NONNULL_BEGIN diff --git a/AltKit/NSError+ALTServerError.m b/AltKit/NSError+ALTServerError.m index eb365a2d..7688d52f 100644 --- a/AltKit/NSError+ALTServerError.m +++ b/AltKit/NSError+ALTServerError.m @@ -61,6 +61,18 @@ NSErrorDomain const AltServerInstallationErrorDomain = @"com.rileytestut.AltServ case ALTServerErrorUnsupportediOSVersion: return NSLocalizedString(@"Your device must be running iOS 12.2 or later to install AltStore.", @""); + + case ALTServerErrorUnknownRequest: + return NSLocalizedString(@"AltServer does not support this request.", @""); + + case ALTServerErrorUnknownResponse: + return NSLocalizedString(@"Received an unknown response from AltServer.", @""); + + case ALTServerErrorInvalidAnisetteData: + return NSLocalizedString(@"Invalid anisette data.", @""); + + case ALTServerErrorPluginNotFound: + return NSLocalizedString(@"Could not connect to Mail plug-in. Please make sure the plug-in is installed and Mail is running, then try again.", @""); } } diff --git a/AltKit/ServerProtocol.swift b/AltKit/ServerProtocol.swift index aa3ffc62..1132b3ce 100644 --- a/AltKit/ServerProtocol.swift +++ b/AltKit/ServerProtocol.swift @@ -7,22 +7,201 @@ // import Foundation +import AltSign public let ALTServerServiceType = "_altserver._tcp" // Can only automatically conform ALTServerError.Code to Codable, not ALTServerError itself extension ALTServerError.Code: Codable {} -protocol ServerMessage: Codable +protocol ServerMessageProtocol: Codable { var version: Int { get } var identifier: String { get } } -public struct PrepareAppRequest: ServerMessage +public enum ServerRequest: Decodable +{ + case anisetteData(AnisetteDataRequest) + case prepareApp(PrepareAppRequest) + case beginInstallation(BeginInstallationRequest) + case unknown(identifier: String, version: Int) + + var identifier: String { + switch self + { + case .anisetteData(let request): return request.identifier + case .prepareApp(let request): return request.identifier + case .beginInstallation(let request): return request.identifier + case .unknown(let identifier, _): return identifier + } + } + + var version: Int { + switch self + { + case .anisetteData(let request): return request.version + case .prepareApp(let request): return request.version + case .beginInstallation(let request): return request.version + case .unknown(_, let version): return version + } + } + + private enum CodingKeys: String, CodingKey + { + case identifier + case version + } + + public init(from decoder: Decoder) throws + { + let container = try decoder.container(keyedBy: CodingKeys.self) + + let version = try container.decode(Int.self, forKey: .version) + + let identifier = try container.decode(String.self, forKey: .identifier) + switch identifier + { + case "AnisetteDataRequest": + let request = try AnisetteDataRequest(from: decoder) + self = .anisetteData(request) + + case "PrepareAppRequest": + let request = try PrepareAppRequest(from: decoder) + self = .prepareApp(request) + + case "BeginInstallationRequest": + let request = try BeginInstallationRequest(from: decoder) + self = .beginInstallation(request) + + default: + self = .unknown(identifier: identifier, version: version) + } + } +} + +public enum ServerResponse: Decodable +{ + case anisetteData(AnisetteDataResponse) + case installationProgress(InstallationProgressResponse) + case error(ErrorResponse) + case unknown(identifier: String, version: Int) + + var identifier: String { + switch self + { + case .anisetteData(let response): return response.identifier + case .installationProgress(let response): return response.identifier + case .error(let response): return response.identifier + case .unknown(let identifier, _): return identifier + } + } + + var version: Int { + switch self + { + case .anisetteData(let response): return response.version + case .installationProgress(let response): return response.version + case .error(let response): return response.version + case .unknown(_, let version): return version + } + } + + private enum CodingKeys: String, CodingKey + { + case identifier + case version + } + + public init(from decoder: Decoder) throws + { + let container = try decoder.container(keyedBy: CodingKeys.self) + + let version = try container.decode(Int.self, forKey: .version) + + let identifier = try container.decode(String.self, forKey: .identifier) + switch identifier + { + case "AnisetteDataResponse": + let response = try AnisetteDataResponse(from: decoder) + self = .anisetteData(response) + + case "InstallationProgressResponse": + let response = try InstallationProgressResponse(from: decoder) + self = .installationProgress(response) + + case "ErrorResponse": + let response = try ErrorResponse(from: decoder) + self = .error(response) + + default: + self = .unknown(identifier: identifier, version: version) + } + } +} + +public struct AnisetteDataRequest: ServerMessageProtocol { public var version = 1 - public var identifier = "PrepareApp" + public var identifier = "AnisetteDataRequest" + + public init() + { + } +} + +public struct AnisetteDataResponse: ServerMessageProtocol +{ + public var version = 1 + public var identifier = "AnisetteDataResponse" + + public var anisetteData: ALTAnisetteData + + private enum CodingKeys: String, CodingKey + { + case identifier + case version + case anisetteData + } + + public init(anisetteData: ALTAnisetteData) + { + self.anisetteData = anisetteData + } + + public init(from decoder: Decoder) throws + { + let container = try decoder.container(keyedBy: CodingKeys.self) + self.version = try container.decode(Int.self, forKey: .version) + self.identifier = try container.decode(String.self, forKey: .identifier) + + let json = try container.decode([String: String].self, forKey: .anisetteData) + + if let anisetteData = ALTAnisetteData(json: json) + { + self.anisetteData = anisetteData + } + else + { + throw DecodingError.dataCorruptedError(forKey: CodingKeys.anisetteData, in: container, debugDescription: "Couuld not parse anisette data from JSON") + } + } + + public func encode(to encoder: Encoder) throws + { + var container = encoder.container(keyedBy: CodingKeys.self) + try container.encode(self.version, forKey: .version) + try container.encode(self.identifier, forKey: .identifier) + + let json = self.anisetteData.json() + try container.encode(json, forKey: .anisetteData) + } +} + +public struct PrepareAppRequest: ServerMessageProtocol +{ + public var version = 1 + public var identifier = "PrepareAppRequest" public var udid: String public var contentSize: Int @@ -34,37 +213,41 @@ public struct PrepareAppRequest: ServerMessage } } -public struct BeginInstallationRequest: ServerMessage +public struct BeginInstallationRequest: ServerMessageProtocol { public var version = 1 - public var identifier = "BeginInstallation" + public var identifier = "BeginInstallationRequest" public init() { } } -public struct ServerResponse: ServerMessage +public struct ErrorResponse: ServerMessageProtocol { public var version = 1 - public var identifier = "ServerResponse" + public var identifier = "ErrorResponse" + + public var error: ALTServerError { + return ALTServerError(self.errorCode) + } + private var errorCode: ALTServerError.Code + + public init(error: ALTServerError) + { + self.errorCode = error.code + } +} + +public struct InstallationProgressResponse: ServerMessageProtocol +{ + public var version = 1 + public var identifier = "InstallationProgressResponse" public var progress: Double - public var error: ALTServerError? { - get { - guard let code = self.errorCode else { return nil } - return ALTServerError(code) - } - set { - self.errorCode = newValue?.code - } - } - private var errorCode: ALTServerError.Code? - - public init(progress: Double, error: ALTServerError?) + public init(progress: Double) { self.progress = progress - self.error = error } } diff --git a/AltPlugin/ALTPluginService.h b/AltPlugin/ALTPluginService.h new file mode 100644 index 00000000..d0c2fb78 --- /dev/null +++ b/AltPlugin/ALTPluginService.h @@ -0,0 +1,19 @@ +// +// ALTPluginService.h +// AltPlugin +// +// Created by Riley Testut on 11/14/19. +// Copyright © 2019 Riley Testut. All rights reserved. +// + +#import + +NS_ASSUME_NONNULL_BEGIN + +@interface ALTPluginService : NSObject + ++ (instancetype)sharedService; + +@end + +NS_ASSUME_NONNULL_END diff --git a/AltPlugin/ALTPluginService.m b/AltPlugin/ALTPluginService.m new file mode 100644 index 00000000..003de970 --- /dev/null +++ b/AltPlugin/ALTPluginService.m @@ -0,0 +1,99 @@ +// +// ALTPluginService.m +// AltPlugin +// +// Created by Riley Testut on 11/14/19. +// Copyright © 2019 Riley Testut. All rights reserved. +// + +#import "ALTPluginService.h" + +#import + +#import "ALTAnisetteData.h" + +@import AppKit; + +@interface AKAppleIDSession : NSObject +- (id)appleIDHeadersForRequest:(id)arg1; +@end + +@interface AKDevice ++ (AKDevice *)currentDevice; +- (NSString *)uniqueDeviceIdentifier; +- (NSString *)serialNumber; +- (NSString *)serverFriendlyDescription; +@end + +@interface ALTPluginService () + +@property (nonatomic, readonly) NSISO8601DateFormatter *dateFormatter; + +@end + +@implementation ALTPluginService + ++ (instancetype)sharedService +{ + static ALTPluginService *_service = nil; + static dispatch_once_t onceToken; + dispatch_once(&onceToken, ^{ + _service = [[self alloc] init]; + }); + + return _service; +} + +- (instancetype)init +{ + self = [super init]; + if (self) + { + _dateFormatter = [[NSISO8601DateFormatter alloc] init]; + } + + return self; +} + ++ (void)initialize +{ + [[ALTPluginService sharedService] start]; +} + +- (void)start +{ + dlopen("/System/Library/PrivateFrameworks/AuthKit.framework/AuthKit", RTLD_NOW); + + [[NSDistributedNotificationCenter defaultCenter] addObserver:self selector:@selector(receiveNotification:) name:@"com.rileytestut.AltServer.FetchAnisetteData" object:nil]; +} + +- (void)receiveNotification:(NSNotification *)notification +{ + NSString *requestUUID = notification.userInfo[@"requestUUID"]; + + NSMutableURLRequest* req = [[NSMutableURLRequest alloc] initWithURL:[[NSURL alloc] initWithString:@"https://developerservices2.apple.com/services/QH65B2/listTeams.action?clientId=XABBG36SBA"]]; + [req setHTTPMethod:@"POST"]; + + AKAppleIDSession *session = [[NSClassFromString(@"AKAppleIDSession") alloc] initWithIdentifier:@"com.apple.gs.xcode.auth"]; + NSDictionary *headers = [session appleIDHeadersForRequest:req]; + + AKDevice *device = [NSClassFromString(@"AKDevice") currentDevice]; + NSDate *date = [self.dateFormatter dateFromString:headers[@"X-Apple-I-Client-Time"]]; + + ALTAnisetteData *anisetteData = [[NSClassFromString(@"ALTAnisetteData") alloc] initWithMachineID:headers[@"X-Apple-I-MD-M"] + oneTimePassword:headers[@"X-Apple-I-MD"] + localUserID:headers[@"X-Apple-I-MD-LU"] + routingInfo:[headers[@"X-Apple-I-MD-RINFO"] longLongValue] + deviceUniqueIdentifier:device.uniqueDeviceIdentifier + deviceSerialNumber:device.serialNumber + deviceDescription:device.serverFriendlyDescription + date:date + locale:[NSLocale currentLocale] + timeZone:[NSTimeZone localTimeZone]]; + + NSData *data = [NSKeyedArchiver archivedDataWithRootObject:anisetteData requiringSecureCoding:YES error:nil]; + + [[NSDistributedNotificationCenter defaultCenter] postNotificationName:@"com.rileytestut.AltServer.AnisetteDataResponse" object:nil userInfo:@{@"requestUUID": requestUUID, @"anisetteData": data} deliverImmediately:YES]; +} + +@end diff --git a/AltPlugin/Info.plist b/AltPlugin/Info.plist new file mode 100644 index 00000000..6188d46b --- /dev/null +++ b/AltPlugin/Info.plist @@ -0,0 +1,62 @@ + + + + + CFBundleDevelopmentRegion + $(DEVELOPMENT_LANGUAGE) + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + $(PRODUCT_BUNDLE_PACKAGE_TYPE) + CFBundleShortVersionString + 1.0 + CFBundleVersion + 1 + NSHumanReadableCopyright + Copyright © 2019 Riley Testut. All rights reserved. + NSPrincipalClass + ALTPluginService + Supported10.14PluginCompatibilityUUIDs + + # UUIDs for versions from 10.12 to 99.99.99 + # For mail version 10.0 (3226) on OS X Version 10.12 (build 16A319) + 36CCB8BB-2207-455E-89BC-B9D6E47ABB5B + # For mail version 10.1 (3251) on OS X Version 10.12.1 (build 16B2553a) + 9054AFD9-2607-489E-8E63-8B09A749BC61 + # For mail version 10.2 (3259) on OS X Version 10.12.2 (build 16D12b) + 1CD3B36A-0E3B-4A26-8F7E-5BDF96AAC97E + # For mail version 10.3 (3273) on OS X Version 10.12.4 (build 16G1036) + 21560BD9-A3CC-482E-9B99-95B7BF61EDC1 + # For mail version 11.0 (3441.0.1) on OS X Version 10.13 (build 17A315i) + C86CD990-4660-4E36-8CDA-7454DEB2E199 + # For mail version 12.0 (3445.100.39) on OS X Version 10.14.1 (build 18B45d) + A4343FAF-AE18-40D0-8A16-DFAE481AF9C1 + # For mail version 13.0 (3594.4.2) on OS X Version 10.15 (build 19A558d) + 6EEA38FB-1A0B-469B-BB35-4C2E0EEA9053 + + Supported10.15PluginCompatibilityUUIDs + + # UUIDs for versions from 10.12 to 99.99.99 + # For mail version 10.0 (3226) on OS X Version 10.12 (build 16A319) + 36CCB8BB-2207-455E-89BC-B9D6E47ABB5B + # For mail version 10.1 (3251) on OS X Version 10.12.1 (build 16B2553a) + 9054AFD9-2607-489E-8E63-8B09A749BC61 + # For mail version 10.2 (3259) on OS X Version 10.12.2 (build 16D12b) + 1CD3B36A-0E3B-4A26-8F7E-5BDF96AAC97E + # For mail version 10.3 (3273) on OS X Version 10.12.4 (build 16G1036) + 21560BD9-A3CC-482E-9B99-95B7BF61EDC1 + # For mail version 11.0 (3441.0.1) on OS X Version 10.13 (build 17A315i) + C86CD990-4660-4E36-8CDA-7454DEB2E199 + # For mail version 12.0 (3445.100.39) on OS X Version 10.14.1 (build 18B45d) + A4343FAF-AE18-40D0-8A16-DFAE481AF9C1 + # For mail version 13.0 (3594.4.2) on OS X Version 10.15 (build 19A558d) + 6EEA38FB-1A0B-469B-BB35-4C2E0EEA9053 + + + diff --git a/AltServer/AltPlugin.mailbundle.zip b/AltServer/AltPlugin.mailbundle.zip new file mode 100644 index 00000000..c14abd9a Binary files /dev/null and b/AltServer/AltPlugin.mailbundle.zip differ diff --git a/AltServer/AltServer-Bridging-Header.h b/AltServer/AltServer-Bridging-Header.h index f02ceeee..05029051 100644 --- a/AltServer/AltServer-Bridging-Header.h +++ b/AltServer/AltServer-Bridging-Header.h @@ -3,3 +3,6 @@ // #import "ALTDeviceManager.h" +#import "ALTWiredConnection.h" +#import "ALTNotificationConnection.h" +#import "AltKit.h" diff --git a/AltServer/AnisetteDataManager.swift b/AltServer/AnisetteDataManager.swift new file mode 100644 index 00000000..e4338649 --- /dev/null +++ b/AltServer/AnisetteDataManager.swift @@ -0,0 +1,79 @@ +// +// AnisetteDataManager.swift +// AltServer +// +// Created by Riley Testut on 11/16/19. +// Copyright © 2019 Riley Testut. All rights reserved. +// + +import Foundation +import AltKit + +class AnisetteDataManager: NSObject +{ + static let shared = AnisetteDataManager() + + private var anisetteDataCompletionHandlers: [String: (Result) -> Void] = [:] + private var anisetteDataTimers: [String: Timer] = [:] + + private override init() + { + super.init() + + DistributedNotificationCenter.default().addObserver(self, selector: #selector(AnisetteDataManager.handleAnisetteDataResponse(_:)), name: Notification.Name("com.rileytestut.AltServer.AnisetteDataResponse"), object: nil) + } + + func requestAnisetteData(_ completion: @escaping (Result) -> Void) + { + let requestUUID = UUID().uuidString + self.anisetteDataCompletionHandlers[requestUUID] = completion + + let timer = Timer(timeInterval: 1.0, repeats: false) { (timer) in + self.finishRequest(forUUID: requestUUID, result: .failure(ALTServerError(.pluginNotFound))) + } + self.anisetteDataTimers[requestUUID] = timer + + RunLoop.main.add(timer, forMode: .default) + + DistributedNotificationCenter.default().postNotificationName(Notification.Name("com.rileytestut.AltServer.FetchAnisetteData"), object: nil, userInfo: ["requestUUID": requestUUID], options: .deliverImmediately) + } +} + +private extension AnisetteDataManager +{ + @objc func handleAnisetteDataResponse(_ notification: Notification) + { + guard let userInfo = notification.userInfo, let requestUUID = userInfo["requestUUID"] as? String else { return } + + if + let archivedAnisetteData = userInfo["anisetteData"] as? Data, + let anisetteData = try? NSKeyedUnarchiver.unarchivedObject(ofClass: ALTAnisetteData.self, from: archivedAnisetteData) + { + if let range = anisetteData.deviceDescription.lowercased().range(of: "(com.apple.mail") + { + var adjustedDescription = anisetteData.deviceDescription[..) + { + let completionHandler = self.anisetteDataCompletionHandlers[requestUUID] + self.anisetteDataCompletionHandlers[requestUUID] = nil + + let timer = self.anisetteDataTimers[requestUUID] + self.anisetteDataTimers[requestUUID] = nil + + timer?.invalidate() + completionHandler?(result) + } +} diff --git a/AltServer/AppDelegate.swift b/AltServer/AppDelegate.swift index c06f7c13..094a50fd 100644 --- a/AltServer/AppDelegate.swift +++ b/AltServer/AppDelegate.swift @@ -12,6 +12,25 @@ import UserNotifications import AltSign import LaunchAtLogin +import STPrivilegedTask + +enum PluginError: LocalizedError +{ + case installationScriptNotFound + case failedToRun(Int) + case scriptError(String) + + var errorDescription: String? { + switch self + { + case .installationScriptNotFound: return NSLocalizedString("The installation script could not be found.", comment: "") + case .failedToRun(let errorCode): return String(format: NSLocalizedString("The installation script could not be run. (%@)", comment: ""), NSNumber(value: errorCode)) + case .scriptError(let output): return output + } + } +} + +private let pluginURL = URL(fileURLWithPath: "/Library/Mail/Bundles/AltPlugin.mailbundle") @NSApplicationMain class AppDelegate: NSObject, NSApplicationDelegate { @@ -25,16 +44,24 @@ class AppDelegate: NSObject, NSApplicationDelegate { @IBOutlet private var appMenu: NSMenu! @IBOutlet private var connectedDevicesMenu: NSMenu! @IBOutlet private var launchAtLoginMenuItem: NSMenuItem! + @IBOutlet private var installMailPluginMenuItem: NSMenuItem! private weak var authenticationAppleIDTextField: NSTextField? private weak var authenticationPasswordTextField: NSSecureTextField? - + + private var isMailPluginInstalled: Bool { + let isMailPluginInstalled = FileManager.default.fileExists(atPath: pluginURL.path) + return isMailPluginInstalled + } + func applicationDidFinishLaunching(_ aNotification: Notification) { UserDefaults.standard.registerDefaults() UNUserNotificationCenter.current().delegate = self + ConnectionManager.shared.start() + ALTDeviceManager.shared.start() let item = NSStatusBar.system.statusItem(withLength: -1) guard let button = item.button else { return } @@ -47,16 +74,20 @@ class AppDelegate: NSObject, NSApplicationDelegate { self.connectedDevicesMenu.delegate = self - if !UserDefaults.standard.didPresentInitialNotification - { - let content = UNMutableNotificationContent() - content.title = NSLocalizedString("AltServer Running", comment: "") - content.body = NSLocalizedString("AltServer runs in the background as a menu bar app listening for AltStore.", comment: "") + UNUserNotificationCenter.current().requestAuthorization(options: [.alert]) { (success, error) in + guard success else { return } - let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: nil) - UNUserNotificationCenter.current().add(request) - - UserDefaults.standard.didPresentInitialNotification = true + if !UserDefaults.standard.didPresentInitialNotification + { + let content = UNMutableNotificationContent() + content.title = NSLocalizedString("AltServer Running", comment: "") + content.body = NSLocalizedString("AltServer runs in the background as a menu bar app listening for AltStore.", comment: "") + + let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: nil) + UNUserNotificationCenter.current().add(request) + + UserDefaults.standard.didPresentInitialNotification = true + } } } @@ -72,11 +103,23 @@ private extension AppDelegate { guard let button = self.statusItem?.button, let superview = button.superview, let window = button.window else { return } - self.connectedDevices = ALTDeviceManager.shared.connectedDevices + self.connectedDevices = ALTDeviceManager.shared.availableDevices self.launchAtLoginMenuItem.state = LaunchAtLogin.isEnabled ? .on : .off self.launchAtLoginMenuItem.action = #selector(AppDelegate.toggleLaunchAtLogin(_:)) + if FileManager.default.fileExists(atPath: pluginURL.path) + { + self.installMailPluginMenuItem.title = NSLocalizedString("Uninstall Mail Plug-in", comment: "") + } + else + { + self.installMailPluginMenuItem.title = NSLocalizedString("Install Mail Plug-in", comment: "") + } + + self.installMailPluginMenuItem.target = self + self.installMailPluginMenuItem.action = #selector(AppDelegate.handleInstallMailPluginMenuItem(_:)) + let x = button.frame.origin.x let y = button.frame.origin.y - 5 @@ -96,11 +139,7 @@ private extension AppDelegate let alert = NSAlert() alert.messageText = NSLocalizedString("Please enter your Apple ID and password.", comment: "") - alert.informativeText = NSLocalizedString(""" -Your Apple ID and password are not saved and are only sent to Apple for authentication. - -If you have two-factor authentication enabled, please create an app-specific password for use with AltStore at https://appleid.apple.com. -""", comment: "") + alert.informativeText = NSLocalizedString("Your Apple ID and password are not saved and are only sent to Apple for authentication.", comment: "") let textFieldSize = NSSize(width: 300, height: 22) @@ -142,6 +181,13 @@ If you have two-factor authentication enabled, please create an app-specific pas let password = passwordTextField.stringValue let device = self.connectedDevices[index] + + if !self.isMailPluginInstalled + { + let result = self.installMailPlugin() + guard result else { return } + } + ALTDeviceManager.shared.installAltStore(to: device, appleID: username, password: password) { (result) in switch result { @@ -153,7 +199,7 @@ If you have two-factor authentication enabled, please create an app-specific pas let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: nil) UNUserNotificationCenter.current().add(request) - case .failure(InstallError.cancelled): + case .failure(InstallError.cancelled), .failure(ALTAppleAPIError.requiresTwoFactorAuthentication): // Ignore break @@ -192,6 +238,74 @@ If you have two-factor authentication enabled, please create an app-specific pas LaunchAtLogin.isEnabled.toggle() } + + @objc func handleInstallMailPluginMenuItem(_ item: NSMenuItem) + { + installMailPlugin() + } + + @discardableResult + func installMailPlugin() -> Bool + { + do + { + let previouslyInstalled = self.isMailPluginInstalled + + if !previouslyInstalled + { + let alert = NSAlert() + alert.messageText = NSLocalizedString("Install Mail Plug-in", comment: "") + alert.informativeText = NSLocalizedString("AltServer requires a Mail plug-in in order to retrieve necessary information about your Apple ID. Would you like to install it now?", comment: "") + + alert.addButton(withTitle: NSLocalizedString("Install Plug-in", comment: "")) + alert.addButton(withTitle: NSLocalizedString("Cancel", comment: "")) + + NSRunningApplication.current.activate(options: .activateIgnoringOtherApps) + + let response = alert.runModal() + guard response == .alertFirstButtonReturn else { return false } + } + + guard let scriptURL = Bundle.main.url(forResource: self.isMailPluginInstalled ? "UninstallPlugin" : "InstallPlugin", withExtension: "sh") else { throw PluginError.installationScriptNotFound } + + try FileManager.default.setAttributes([.posixPermissions: 0o777], ofItemAtPath: scriptURL.path) + + let task = STPrivilegedTask() + task.setLaunchPath(scriptURL.path) + task.setCurrentDirectoryPath(scriptURL.deletingLastPathComponent().path) + + let errorCode = task.launch() + guard errorCode == 0 else { throw PluginError.failedToRun(Int(errorCode)) } + + task.waitUntilExit() + + if + let outputData = task.outputFileHandle()?.readDataToEndOfFile(), + let outputString = String(data: outputData, encoding: .utf8), !outputString.isEmpty + { + throw PluginError.scriptError(outputString) + } + + if !previouslyInstalled && self.isMailPluginInstalled + { + let alert = NSAlert() + alert.messageText = NSLocalizedString("Mail Plug-in Installed", comment: "") + alert.informativeText = NSLocalizedString("Please restart Mail and enable AltPlugin in Mail's Preferences. Mail must be running when installing or refreshing apps with AltServer.", comment: "") + alert.runModal() + } + + return true + } + catch + { + let alert = NSAlert() + alert.messageText = self.isMailPluginInstalled ? NSLocalizedString("Failed to Uninstall Mail Plug-in", comment: "") : NSLocalizedString("Failed to Install Mail Plug-in", comment: "") + alert.informativeText = error.localizedDescription + alert.runModal() + + return false + } + } } extension AppDelegate: NSMenuDelegate diff --git a/AltServer/Base.lproj/Main.storyboard b/AltServer/Base.lproj/Main.storyboard index c7903d48..d2a97fe9 100644 --- a/AltServer/Base.lproj/Main.storyboard +++ b/AltServer/Base.lproj/Main.storyboard @@ -1,7 +1,8 @@ - + - + + @@ -10,11 +11,11 @@ - + - + @@ -26,7 +27,7 @@ - + @@ -61,9 +62,11 @@ + + @@ -98,7 +101,17 @@ + + + + + + + + + + diff --git a/AltServer/Connections/ALTNotificationConnection+Private.h b/AltServer/Connections/ALTNotificationConnection+Private.h new file mode 100644 index 00000000..ee484915 --- /dev/null +++ b/AltServer/Connections/ALTNotificationConnection+Private.h @@ -0,0 +1,24 @@ +// +// ALTNotificationConnection+Private.h +// AltServer +// +// Created by Riley Testut on 1/10/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +#import "ALTNotificationConnection.h" + +#include +#include + +NS_ASSUME_NONNULL_BEGIN + +@interface ALTNotificationConnection () + +@property (nonatomic, readonly) np_client_t client; + +- (instancetype)initWithDevice:(ALTDevice *)device client:(np_client_t)client; + +@end + +NS_ASSUME_NONNULL_END diff --git a/AltServer/Connections/ALTNotificationConnection.h b/AltServer/Connections/ALTNotificationConnection.h new file mode 100644 index 00000000..50a0f59d --- /dev/null +++ b/AltServer/Connections/ALTNotificationConnection.h @@ -0,0 +1,30 @@ +// +// ALTNotificationConnection.h +// AltServer +// +// Created by Riley Testut on 1/10/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +#import + +NS_ASSUME_NONNULL_BEGIN + +NS_SWIFT_NAME(NotificationConnection) +@interface ALTNotificationConnection : NSObject + +@property (nonatomic, copy, readonly) ALTDevice *device; + +@property (nonatomic, copy, nullable) void (^receivedNotificationHandler)(CFNotificationName notification); + +- (void)startListeningForNotifications:(NSArray *)notifications + completionHandler:(void (^)(BOOL success, NSError *_Nullable error))completionHandler; + +- (void)sendNotification:(CFNotificationName)notification + completionHandler:(void (^)(BOOL success, NSError *_Nullable error))completionHandler; + +- (void)disconnect; + +@end + +NS_ASSUME_NONNULL_END diff --git a/AltServer/Connections/ALTNotificationConnection.m b/AltServer/Connections/ALTNotificationConnection.m new file mode 100644 index 00000000..6a3a895d --- /dev/null +++ b/AltServer/Connections/ALTNotificationConnection.m @@ -0,0 +1,93 @@ +// +// ALTNotificationConnection.m +// AltServer +// +// Created by Riley Testut on 1/10/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +#import "ALTNotificationConnection+Private.h" +#import "AltKit.h" + +void ALTDeviceReceivedNotification(const char *notification, void *user_data); + +@implementation ALTNotificationConnection + +- (instancetype)initWithDevice:(ALTDevice *)device client:(np_client_t)client +{ + self = [super init]; + if (self) + { + _device = [device copy]; + _client = client; + } + + return self; +} + +- (void)dealloc +{ + [self disconnect]; +} + +- (void)disconnect +{ + np_client_free(self.client); + _client = nil; +} + +- (void)startListeningForNotifications:(NSArray *)notifications completionHandler:(void (^)(BOOL, NSError * _Nullable))completionHandler +{ + dispatch_async(dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{ + const char **notificationNames = (const char **)malloc((notifications.count + 1) * sizeof(char *)); + for (int i = 0; i < notifications.count; i++) + { + NSString *name = notifications[i]; + notificationNames[i] = name.UTF8String; + } + notificationNames[notifications.count] = NULL; // Must have terminating NULL entry. + + np_error_t result = np_observe_notifications(self.client, notificationNames); + if (result != NP_E_SUCCESS) + { + return completionHandler(NO, [NSError errorWithDomain:AltServerErrorDomain code:ALTServerErrorLostConnection userInfo:nil]); + } + + result = np_set_notify_callback(self.client, ALTDeviceReceivedNotification, (__bridge void *)self); + if (result != NP_E_SUCCESS) + { + return completionHandler(NO, [NSError errorWithDomain:AltServerErrorDomain code:ALTServerErrorLostConnection userInfo:nil]); + } + + completionHandler(YES, nil); + + free(notificationNames); + }); +} + +- (void)sendNotification:(CFNotificationName)notification completionHandler:(void (^)(BOOL, NSError * _Nullable))completionHandler +{ + dispatch_async(dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{ + np_error_t result = np_post_notification(self.client, [(__bridge NSString *)notification UTF8String]); + if (result == NP_E_SUCCESS) + { + completionHandler(YES, nil); + } + else + { + completionHandler(NO, [NSError errorWithDomain:AltServerErrorDomain code:ALTServerErrorLostConnection userInfo:nil]); + } + }); +} + +@end + +void ALTDeviceReceivedNotification(const char *notification, void *user_data) +{ + ALTNotificationConnection *connection = (__bridge ALTNotificationConnection *)user_data; + + if (connection.receivedNotificationHandler) + { + connection.receivedNotificationHandler((__bridge CFNotificationName)@(notification)); + } +} diff --git a/AltServer/Connections/ALTWiredConnection+Private.h b/AltServer/Connections/ALTWiredConnection+Private.h new file mode 100644 index 00000000..24dc2c85 --- /dev/null +++ b/AltServer/Connections/ALTWiredConnection+Private.h @@ -0,0 +1,23 @@ +// +// ALTWiredConnection+Private.h +// AltServer +// +// Created by Riley Testut on 1/10/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +#import "ALTWiredConnection.h" + +#include + +NS_ASSUME_NONNULL_BEGIN + +@interface ALTWiredConnection () + +@property (nonatomic, readonly) idevice_connection_t connection; + +- (instancetype)initWithDevice:(ALTDevice *)device connection:(idevice_connection_t)connection; + +@end + +NS_ASSUME_NONNULL_END diff --git a/AltServer/Connections/ALTWiredConnection.h b/AltServer/Connections/ALTWiredConnection.h new file mode 100644 index 00000000..05801f98 --- /dev/null +++ b/AltServer/Connections/ALTWiredConnection.h @@ -0,0 +1,25 @@ +// +// ALTWiredConnection.h +// AltServer +// +// Created by Riley Testut on 1/10/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +#import + +NS_ASSUME_NONNULL_BEGIN + +NS_SWIFT_NAME(WiredConnection) +@interface ALTWiredConnection : NSObject + +@property (nonatomic, copy, readonly) ALTDevice *device; + +- (void)sendData:(NSData *)data completionHandler:(void (^)(BOOL, NSError * _Nullable))completionHandler; +- (void)receiveDataWithExpectedSize:(NSInteger)expectedSize completionHandler:(void (^)(NSData * _Nullable, NSError * _Nullable))completionHandler; + +- (void)disconnect; + +@end + +NS_ASSUME_NONNULL_END diff --git a/AltServer/Connections/ALTWiredConnection.m b/AltServer/Connections/ALTWiredConnection.m new file mode 100644 index 00000000..0b941730 --- /dev/null +++ b/AltServer/Connections/ALTWiredConnection.m @@ -0,0 +1,101 @@ +// +// ALTWiredConnection.m +// AltServer +// +// Created by Riley Testut on 1/10/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +#import "ALTWiredConnection+Private.h" +#import "AltKit.h" + +@implementation ALTWiredConnection + +- (instancetype)initWithDevice:(ALTDevice *)device connection:(idevice_connection_t)connection +{ + self = [super init]; + if (self) + { + _device = [device copy]; + _connection = connection; + } + + return self; +} + +- (void)dealloc +{ + [self disconnect]; +} + +- (void)disconnect +{ + idevice_disconnect(self.connection); + _connection = nil; +} + +- (void)sendData:(NSData *)data completionHandler:(void (^)(BOOL, NSError * _Nullable))completionHandler +{ + void (^finish)(NSError *error) = ^(NSError *error) { + if (error != nil) + { + NSLog(@"Send Error: %@", error); + completionHandler(NO, error); + } + else + { + completionHandler(YES, nil); + } + }; + + dispatch_async(dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{ + NSMutableData *mutableData = [data mutableCopy]; + while (mutableData.length > 0) + { + uint32_t sentBytes = 0; + if (idevice_connection_send(self.connection, (const char *)mutableData.bytes, (int32_t)mutableData.length, &sentBytes) != IDEVICE_E_SUCCESS) + { + return finish([NSError errorWithDomain:AltServerErrorDomain code:ALTServerErrorLostConnection userInfo:nil]); + } + + [mutableData replaceBytesInRange:NSMakeRange(0, sentBytes) withBytes:NULL length:0]; + } + + finish(nil); + }); +} + +- (void)receiveDataWithExpectedSize:(NSInteger)expectedSize completionHandler:(void (^)(NSData * _Nullable, NSError * _Nullable))completionHandler +{ + void (^finish)(NSData *data, NSError *error) = ^(NSData *data, NSError *error) { + if (error != nil) + { + NSLog(@"Receive Data Error: %@", error); + } + + completionHandler(data, error); + }; + + dispatch_async(dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{ + char bytes[4096]; + NSMutableData *receivedData = [NSMutableData dataWithCapacity:expectedSize]; + + while (receivedData.length < expectedSize) + { + uint32_t size = MIN(4096, (uint32_t)expectedSize - (uint32_t)receivedData.length); + + uint32_t receivedBytes = 0; + if (idevice_connection_receive_timeout(self.connection, bytes, size, &receivedBytes, 0) != IDEVICE_E_SUCCESS) + { + return finish(nil, [NSError errorWithDomain:AltServerErrorDomain code:ALTServerErrorLostConnection userInfo:nil]); + } + + NSData *data = [NSData dataWithBytesNoCopy:bytes length:receivedBytes freeWhenDone:NO]; + [receivedData appendData:data]; + } + + finish(receivedData, nil); + }); +} + +@end diff --git a/AltServer/Connections/ClientConnection.swift b/AltServer/Connections/ClientConnection.swift new file mode 100644 index 00000000..33b5562c --- /dev/null +++ b/AltServer/Connections/ClientConnection.swift @@ -0,0 +1,231 @@ +// +// ClientConnection.swift +// AltServer +// +// Created by Riley Testut on 1/9/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +import Foundation +import Network + +import AltKit +import AltSign + +extension ClientConnection +{ + enum Connection + { + case wireless(NWConnection) + case wired(WiredConnection) + } +} + +class ClientConnection +{ + let connection: Connection + + init(connection: Connection) + { + self.connection = connection + } + + func disconnect() + { + switch self.connection + { + case .wireless(let connection): + switch connection.state + { + case .cancelled, .failed: + print("Disconnecting from \(connection.endpoint)...") + + default: + // State update handler might call this method again. + connection.cancel() + } + + case .wired(let connection): + connection.disconnect() + } + } + + func send(_ response: T, shouldDisconnect: Bool = false, completionHandler: @escaping (Result) -> Void) + { + func finish(_ result: Result) + { + completionHandler(result) + + if shouldDisconnect + { + // Add short delay to prevent us from dropping connection too quickly. + DispatchQueue.global().asyncAfter(deadline: .now() + 1.0) { + self.disconnect() + } + } + } + + do + { + let data = try JSONEncoder().encode(response) + let responseSize = withUnsafeBytes(of: Int32(data.count)) { Data($0) } + + self.send(responseSize) { (result) in + switch result + { + case .failure: finish(.failure(.init(.lostConnection))) + case .success: + + self.send(data) { (result) in + switch result + { + case .failure: finish(.failure(.init(.lostConnection))) + case .success: finish(.success(())) + } + } + } + } + } + catch + { + finish(.failure(.init(.invalidResponse))) + } + } + + func receiveRequest(completionHandler: @escaping (Result) -> Void) + { + let size = MemoryLayout.size + + print("Receiving request size") + self.receiveData(expectedBytes: size) { (result) in + do + { + let data = try result.get() + + print("Receiving request...") + let expectedBytes = Int(data.withUnsafeBytes { $0.load(as: Int32.self) }) + self.receiveData(expectedBytes: expectedBytes) { (result) in + do + { + let data = try result.get() + let request = try JSONDecoder().decode(ServerRequest.self, from: data) + + print("Received installation request:", request) + completionHandler(.success(request)) + } + catch + { + completionHandler(.failure(ALTServerError(error))) + } + } + } + catch + { + completionHandler(.failure(ALTServerError(error))) + } + } + } + + func send(_ data: Data, completionHandler: @escaping (Result) -> Void) + { + switch self.connection + { + case .wireless(let connection): + connection.send(content: data, completion: .contentProcessed { (error) in + if let error = error + { + completionHandler(.failure(error)) + } + else + { + completionHandler(.success(())) + } + }) + + case .wired(let connection): + connection.send(data) { (success, error) in + if !success + { + completionHandler(.failure(ALTServerError(.lostConnection))) + } + else + { + completionHandler(.success(())) + } + } + } + } + + func receiveData(expectedBytes: Int, completionHandler: @escaping (Result) -> Void) + { + func finish(data: Data?, error: Error?) + { + do + { + let data = try self.process(data: data, error: error) + completionHandler(.success(data)) + } + catch + { + completionHandler(.failure(ALTServerError(error))) + } + } + + switch self.connection + { + case .wireless(let connection): + connection.receive(minimumIncompleteLength: expectedBytes, maximumLength: expectedBytes) { (data, _, _, error) in + finish(data: data, error: error) + } + + case .wired(let connection): + connection.receiveData(withExpectedSize: expectedBytes) { (data, error) in + finish(data: data, error: error) + } + } + } +} + +extension ClientConnection: CustomStringConvertible +{ + var description: String { + switch self.connection + { + case .wireless(let connection): return "\(connection.endpoint) (Wireless)" + case .wired(let connection): return "\(connection.device.name) (Wired)" + } + } +} + +private extension ClientConnection +{ + func process(data: Data?, error: Error?) throws -> Data + { + do + { + do + { + guard let data = data else { throw error ?? ALTServerError(.unknown) } + return data + } + catch let error as NWError + { + print("Error receiving data from connection \(connection)", error) + + throw ALTServerError(.lostConnection) + } + catch + { + throw error + } + } + catch let error as ALTServerError + { + throw error + } + catch + { + preconditionFailure("A non-ALTServerError should never be thrown from this method.") + } + } +} diff --git a/AltServer/Connections/ConnectionManager.swift b/AltServer/Connections/ConnectionManager.swift index 055e873b..94cef17a 100644 --- a/AltServer/Connections/ConnectionManager.swift +++ b/AltServer/Connections/ConnectionManager.swift @@ -8,6 +8,7 @@ import Foundation import Network +import AppKit import AltKit @@ -53,10 +54,13 @@ class ConnectionManager private lazy var listener = self.makeListener() private let dispatchQueue = DispatchQueue(label: "com.rileytestut.AltServer.connections", qos: .utility) - private var connections = [NWConnection]() + private var connections = [ClientConnection]() + private var notificationConnections = [ALTDevice: NotificationConnection]() private init() { + NotificationCenter.default.addObserver(self, selector: #selector(ConnectionManager.deviceDidConnect(_:)), name: .deviceManagerDeviceDidConnect, object: nil) + NotificationCenter.default.addObserver(self, selector: #selector(ConnectionManager.deviceDidDisconnect(_:)), name: .deviceManagerDeviceDidDisconnect, object: nil) } func start() @@ -76,6 +80,16 @@ class ConnectionManager default: break } } + + func disconnect(_ connection: ClientConnection) + { + connection.disconnect() + + if let index = self.connections.firstIndex(where: { $0 === connection }) + { + self.connections.remove(at: index) + } + } } private extension ConnectionManager @@ -126,68 +140,18 @@ private extension ConnectionManager } listener.newConnectionHandler = { [weak self] (connection) in - self?.awaitRequest(from: connection) + self?.prepare(connection) } return listener } - func disconnect(_ connection: NWConnection) + func prepare(_ connection: NWConnection) { - switch connection.state - { - case .cancelled, .failed: - print("Disconnecting from \(connection.endpoint)...") - - if let index = self.connections.firstIndex(where: { $0 === connection }) - { - self.connections.remove(at: index) - } - - default: - // State update handler will call this method again. - connection.cancel() - } - } - - func process(data: Data?, error: NWError?, from connection: NWConnection) throws -> Data - { - do - { - do - { - guard let data = data else { throw error ?? ALTServerError(.unknown) } - return data - } - catch let error as NWError - { - print("Error receiving data from connection \(connection)", error) - - throw ALTServerError(.lostConnection) - } - catch - { - throw error - } - } - catch let error as ALTServerError - { - throw error - } - catch - { - preconditionFailure("A non-ALTServerError should never be thrown from this method.") - } - } -} - -private extension ConnectionManager -{ - func awaitRequest(from connection: NWConnection) - { - guard !self.connections.contains(where: { $0 === connection }) else { return } - self.connections.append(connection) + let clientConnection = ClientConnection(connection: .wireless(connection)) + guard !self.connections.contains(where: { $0 === clientConnection }) else { return } + self.connections.append(clientConnection) connection.stateUpdateHandler = { [weak self] (state) in switch state @@ -196,20 +160,17 @@ private extension ConnectionManager case .ready: print("Connected to client:", connection.endpoint) - - self?.receiveApp(from: connection) { (result) in - self?.finish(connection: connection, error: result.error) - } + self?.handleRequest(for: clientConnection) case .waiting: print("Waiting for connection...") case .failed(let error): print("Failed to connect to service \(connection.endpoint).", error) - self?.disconnect(connection) + self?.disconnect(clientConnection) case .cancelled: - self?.disconnect(connection) + self?.disconnect(clientConnection) @unknown default: break } @@ -217,8 +178,124 @@ private extension ConnectionManager connection.start(queue: self.dispatchQueue) } +} + +private extension ConnectionManager +{ + func startNotificationConnection(to device: ALTDevice) + { + ALTDeviceManager.shared.startNotificationConnection(to: device) { (connection, error) in + guard let connection = connection else { return } + + let notifications: [CFNotificationName] = [.wiredServerConnectionAvailableRequest, .wiredServerConnectionStartRequest] + connection.startListening(forNotifications: notifications.map { String($0.rawValue) }) { (success, error) in + guard success else { return } + + connection.receivedNotificationHandler = { [weak self, weak connection] (notification) in + guard let self = self, let connection = connection else { return } + self.handle(notification, for: connection) + } + + self.notificationConnections[device] = connection + } + } + } - func receiveApp(from connection: NWConnection, completionHandler: @escaping (Result) -> Void) + func stopNotificationConnection(to device: ALTDevice) + { + guard let connection = self.notificationConnections[device] else { return } + connection.disconnect() + + self.notificationConnections[device] = nil + } + + func handle(_ notification: CFNotificationName, for connection: NotificationConnection) + { + switch notification + { + case .wiredServerConnectionAvailableRequest: + connection.sendNotification(.wiredServerConnectionAvailableResponse) { (success, error) in + if let error = error, !success + { + print("Error sending wired server connection response.", error) + } + else + { + print("Sent wired server connection available response!") + } + } + + case .wiredServerConnectionStartRequest: + ALTDeviceManager.shared.startWiredConnection(to: connection.device) { (wiredConnection, error) in + if let wiredConnection = wiredConnection + { + print("Started wired server connection!") + + let clientConnection = ClientConnection(connection: .wired(wiredConnection)) + self.handleRequest(for: clientConnection) + } + else if let error = error + { + print("Error starting wired server connection.", error) + } + } + + default: break + } + } +} + +private extension ConnectionManager +{ + func handleRequest(for connection: ClientConnection) + { + connection.receiveRequest() { (result) in + print("Received initial request with result:", result) + + switch result + { + case .failure(let error): + let response = ErrorResponse(error: ALTServerError(error)) + connection.send(response, shouldDisconnect: true) { (result) in + print("Sent error response with result:", result) + } + + case .success(.anisetteData(let request)): + self.handleAnisetteDataRequest(request, for: connection) + + case .success(.prepareApp(let request)): + self.handlePrepareAppRequest(request, for: connection) + + case .success: + let response = ErrorResponse(error: ALTServerError(.unknownRequest)) + connection.send(response, shouldDisconnect: true) { (result) in + print("Sent unknown request response with result:", result) + } + } + } + } + + func handleAnisetteDataRequest(_ request: AnisetteDataRequest, for connection: ClientConnection) + { + AnisetteDataManager.shared.requestAnisetteData { (result) in + switch result + { + case .failure(let error): + let errorResponse = ErrorResponse(error: ALTServerError(error)) + connection.send(errorResponse, shouldDisconnect: true) { (result) in + print("Sent anisette data error response with result:", result) + } + + case .success(let anisetteData): + let response = AnisetteDataResponse(anisetteData: anisetteData) + connection.send(response, shouldDisconnect: true) { (result) in + print("Sent anisette data response with result:", result) + } + } + } + } + + func handlePrepareAppRequest(_ request: PrepareAppRequest, for connection: ClientConnection) { var temporaryURL: URL? @@ -230,83 +307,75 @@ private extension ConnectionManager catch { print("Failed to remove .ipa.", error) } } - completionHandler(result) + switch result + { + case .failure(let error): + print("Failed to process request from \(connection).", error) + + let response = ErrorResponse(error: ALTServerError(error)) + connection.send(response, shouldDisconnect: true) { (result) in + print("Sent install app error response to \(connection) with result:", result) + } + + case .success: + print("Processed request from \(connection).") + + let response = InstallationProgressResponse(progress: 1.0) + connection.send(response, shouldDisconnect: true) { (result) in + print("Sent install app response to \(connection) with result:", result) + } + } } - self.receive(PrepareAppRequest.self, from: connection) { (result) in - print("Received request with result:", result) + self.receiveApp(for: request, from: connection) { (result) in + print("Received app with result:", result) switch result { case .failure(let error): finish(.failure(error)) - case .success(let request): - self.receiveApp(for: request, from: connection) { (result) in - print("Received app with result:", result) + case .success(let fileURL): + temporaryURL = fileURL + + print("Awaiting begin installation request...") + + connection.receiveRequest() { (result) in + print("Received begin installation request with result:", result) switch result { case .failure(let error): finish(.failure(error)) - case .success(let request, let fileURL): - temporaryURL = fileURL + case .success(.beginInstallation): + print("Installing to device \(request.udid)...") - print("Awaiting begin installation request...") - - self.receive(BeginInstallationRequest.self, from: connection) { (result) in - print("Received begin installation request with result:", result) - + self.installApp(at: fileURL, toDeviceWithUDID: request.udid, connection: connection) { (result) in + print("Installed to device with result:", result) switch result { case .failure(let error): finish(.failure(error)) - case .success: - print("Installing to device \(request.udid)...") - - self.installApp(at: fileURL, toDeviceWithUDID: request.udid, connection: connection) { (result) in - print("Installed to device with result:", result) - switch result - { - case .failure(let error): finish(.failure(error)) - case .success: finish(.success(())) - } - } + case .success: finish(.success(())) } } + + case .success: + let response = ErrorResponse(error: ALTServerError(.unknownRequest)) + connection.send(response, shouldDisconnect: true) { (result) in + print("Sent unknown request error response to \(connection) with result:", result) + } } } } } } - func finish(connection: NWConnection, error: ALTServerError?) + func receiveApp(for request: PrepareAppRequest, from connection: ClientConnection, completionHandler: @escaping (Result) -> Void) { - if let error = error - { - print("Failed to process request from \(connection.endpoint).", error) - } - else - { - print("Processed request from \(connection.endpoint).") - } - - let response = ServerResponse(progress: 1.0, error: error) - - self.send(response, to: connection) { (result) in - print("Sent response to \(connection.endpoint) with result:", result) - - self.disconnect(connection) - } - } - - func receiveApp(for request: PrepareAppRequest, from connection: NWConnection, completionHandler: @escaping (Result<(PrepareAppRequest, URL), ALTServerError>) -> Void) - { - connection.receive(minimumIncompleteLength: request.contentSize, maximumLength: request.contentSize) { (data, _, _, error) in + connection.receiveData(expectedBytes: request.contentSize) { (result) in do { print("Received app data!") - let data = try self.process(data: data, error: error, from: connection) - - print("Processed app data!") - + let data = try result.get() + guard ALTDeviceManager.shared.availableDevices.contains(where: { $0.identifier == request.udid }) else { throw ALTServerError(.deviceNotFound) } print("Writing app data...") @@ -316,7 +385,7 @@ private extension ConnectionManager print("Wrote app to URL:", temporaryURL) - completionHandler(.success((request, temporaryURL))) + completionHandler(.success(temporaryURL)) } catch { @@ -327,7 +396,7 @@ private extension ConnectionManager } } - func installApp(at fileURL: URL, toDeviceWithUDID udid: String, connection: NWConnection, completionHandler: @escaping (Result) -> Void) + func installApp(at fileURL: URL, toDeviceWithUDID udid: String, connection: ClientConnection, completionHandler: @escaping (Result) -> Void) { let serialQueue = DispatchQueue(label: "com.altstore.ConnectionManager.installQueue", qos: .default) var isSending = false @@ -356,9 +425,9 @@ private extension ConnectionManager isSending = true print("Progress:", progress.fractionCompleted) - let response = ServerResponse(progress: progress.fractionCompleted, error: nil) + let response = InstallationProgressResponse(progress: progress.fractionCompleted) - self.send(response, to: connection) { (result) in + connection.send(response) { (result) in serialQueue.async { isSending = false } @@ -366,79 +435,19 @@ private extension ConnectionManager } }) } +} - func send(_ response: T, to connection: NWConnection, completionHandler: @escaping (Result) -> Void) +private extension ConnectionManager +{ + @objc func deviceDidConnect(_ notification: Notification) { - do - { - let data = try JSONEncoder().encode(response) - let responseSize = withUnsafeBytes(of: Int32(data.count)) { Data($0) } - - connection.send(content: responseSize, completion: .contentProcessed { (error) in - do - { - if let error = error - { - throw error - } - - connection.send(content: data, completion: .contentProcessed { (error) in - if error != nil - { - completionHandler(.failure(.init(.lostConnection))) - } - else - { - completionHandler(.success(())) - } - }) - } - catch - { - completionHandler(.failure(.init(.lostConnection))) - } - }) - } - catch - { - completionHandler(.failure(.init(.invalidResponse))) - } + guard let device = notification.object as? ALTDevice else { return } + self.startNotificationConnection(to: device) } - func receive(_ responseType: T.Type, from connection: NWConnection, completionHandler: @escaping (Result) -> Void) + @objc func deviceDidDisconnect(_ notification: Notification) { - let size = MemoryLayout.size - - print("Receiving request size") - connection.receive(minimumIncompleteLength: size, maximumLength: size) { (data, _, _, error) in - do - { - let data = try self.process(data: data, error: error, from: connection) - - print("Receiving request...") - - let expectedBytes = Int(data.withUnsafeBytes { $0.load(as: Int32.self) }) - connection.receive(minimumIncompleteLength: expectedBytes, maximumLength: expectedBytes) { (data, _, _, error) in - do - { - let data = try self.process(data: data, error: error, from: connection) - - let request = try JSONDecoder().decode(T.self, from: data) - - print("Received installation request:", request) - - completionHandler(.success(request)) - } - catch - { - completionHandler(.failure(ALTServerError(error))) - } - } - } - catch - { - completionHandler(.failure(ALTServerError(error))) - } - } + guard let device = notification.object as? ALTDevice else { return } + self.stopNotificationConnection(to: device) } } diff --git a/AltServer/Devices/ALTDeviceManager+Installation.swift b/AltServer/Devices/ALTDeviceManager+Installation.swift index 8ab57eed..d92b5503 100644 --- a/AltServer/Devices/ALTDeviceManager+Installation.swift +++ b/AltServer/Devices/ALTDeviceManager+Installation.swift @@ -8,6 +8,13 @@ import Cocoa import UserNotifications +import ObjectiveC + +#if STAGING +private let appURL = URL(string: "https://f000.backblazeb2.com/file/altstore-staging/altstore.ipa")! +#else +private let appURL = URL(string: "https://f000.backblazeb2.com/file/altstore/altstore.ipa")! +#endif enum InstallError: LocalizedError { @@ -49,126 +56,147 @@ extension ALTDeviceManager try? FileManager.default.removeItem(at: destinationDirectoryURL) } - self.authenticate(appleID: appleID, password: password) { (result) in + AnisetteDataManager.shared.requestAnisetteData { (result) in do { - let account = try result.get() + let anisetteData = try result.get() - self.fetchTeam(for: account) { (result) in + self.authenticate(appleID: appleID, password: password, anisetteData: anisetteData) { (result) in do { - let team = try result.get() + let (account, session) = try result.get() - self.register(device, team: team) { (result) in + self.fetchTeam(for: account, session: session) { (result) in do { - let device = try result.get() + let team = try result.get() - self.fetchCertificate(for: team) { (result) in + self.register(device, team: team, session: session) { (result) in do { - let certificate = try result.get() + let device = try result.get() - let content = UNMutableNotificationContent() - content.title = String(format: NSLocalizedString("Installing AltStore to %@...", comment: ""), device.name) - content.body = NSLocalizedString("This may take a few seconds.", comment: "") - - let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: nil) - UNUserNotificationCenter.current().add(request) - - self.downloadApp { (result) in + self.fetchCertificate(for: team, session: session) { (result) in do { - let fileURL = try result.get() + let certificate = try result.get() - try FileManager.default.createDirectory(at: destinationDirectoryURL, withIntermediateDirectories: true, attributes: nil) + let content = UNMutableNotificationContent() + content.title = String(format: NSLocalizedString("Installing AltStore to %@...", comment: ""), device.name) + content.body = NSLocalizedString("This may take a few seconds.", comment: "") - let appBundleURL = try FileManager.default.unzipAppBundle(at: fileURL, toDirectory: destinationDirectoryURL) + let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: nil) + UNUserNotificationCenter.current().add(request) - do - { - try FileManager.default.removeItem(at: fileURL) - } - catch - { - print("Failed to remove downloaded .ipa.", error) - } - - guard let application = ALTApplication(fileURL: appBundleURL) else { throw ALTError(.invalidApp) } - - self.registerAppID(name: "AltStore", identifier: "com.rileytestut.AltStore", team: team) { (result) in + self.downloadApp { (result) in do { - let appID = try result.get() + let fileURL = try result.get() - self.updateFeatures(for: appID, app: application, team: team) { (result) in + try FileManager.default.createDirectory(at: destinationDirectoryURL, withIntermediateDirectories: true, attributes: nil) + + let appBundleURL = try FileManager.default.unzipAppBundle(at: fileURL, toDirectory: destinationDirectoryURL) + + do + { + try FileManager.default.removeItem(at: fileURL) + } + catch + { + print("Failed to remove downloaded .ipa.", error) + } + + guard let application = ALTApplication(fileURL: appBundleURL) else { throw ALTError(.invalidApp) } + + // Refresh anisette data to prevent session timeouts. + AnisetteDataManager.shared.requestAnisetteData { (result) in do { - let appID = try result.get() + let anisetteData = try result.get() + session.anisetteData = anisetteData - self.fetchProvisioningProfile(for: appID, team: team) { (result) in + self.registerAppID(name: "AltStore", identifier: "com.rileytestut.AltStore", team: team, session: session) { (result) in do { - let provisioningProfile = try result.get() + let appID = try result.get() - self.install(application, to: device, team: team, appID: appID, certificate: certificate, profile: provisioningProfile) { (result) in - finish(result.error, title: "Failed to Install AltStore") + self.updateFeatures(for: appID, app: application, team: team, session: session) { (result) in + do + { + let appID = try result.get() + + self.fetchProvisioningProfile(for: appID, team: team, session: session) { (result) in + do + { + let provisioningProfile = try result.get() + + self.install(application, to: device, team: team, appID: appID, certificate: certificate, profile: provisioningProfile) { (result) in + finish(result.error, title: "Failed to Install AltStore") + } + } + catch + { + finish(error, title: "Failed to Fetch Provisioning Profile") + } + } + } + catch + { + finish(error, title: "Failed to Update App ID") + } } } catch { - finish(error, title: "Failed to Fetch Provisioning Profile") + finish(error, title: "Failed to Register App") } } } catch { - finish(error, title: "Failed to Update App ID") + finish(error, title: "Failed to Refresh Anisette Data") } } } catch { - finish(error, title: "Failed to Register App") + finish(error, title: "Failed to Download AltStore") } } } catch { - finish(error, title: "Failed to Download AltStore") - return + finish(error, title: "Failed to Fetch Certificate") } } } catch { - finish(error, title: "Failed to Fetch Certificate") + finish(error, title: "Failed to Register Device") } } } catch { - finish(error, title: "Failed to Register Device") + finish(error, title: "Failed to Fetch Team") } } } catch { - finish(error, title: "Failed to Fetch Team") + finish(error, title: "Failed to Authenticate") } } } catch { - finish(error, title: "Failed to Authenticate") + finish(error, title: "Failed to Fetch Anisette Data") } } } func downloadApp(completionHandler: @escaping (Result) -> Void) { - let appURL = URL(string: "https://f000.backblazeb2.com/file/altstore/altstore.ipa")! - let downloadTask = URLSession.shared.downloadTask(with: appURL) { (fileURL, response, error) in do { @@ -184,15 +212,57 @@ extension ALTDeviceManager downloadTask.resume() } - func authenticate(appleID: String, password: String, completionHandler: @escaping (Result) -> Void) + func authenticate(appleID: String, password: String, anisetteData: ALTAnisetteData, completionHandler: @escaping (Result<(ALTAccount, ALTAppleAPISession), Error>) -> Void) { - ALTAppleAPI.shared.authenticate(appleID: appleID, password: password) { (account, error) in - let result = Result(account, error) - completionHandler(result) + func handleVerificationCode(_ completionHandler: @escaping (String?) -> Void) + { + DispatchQueue.main.async { + let alert = NSAlert() + alert.messageText = NSLocalizedString("Two-Factor Authentication Enabled", comment: "") + alert.informativeText = NSLocalizedString("Please enter the 6-digit verification code that was sent to your Apple devices.", comment: "") + + let textField = NSTextField(frame: NSRect(x: 0, y: 0, width: 300, height: 22)) + textField.delegate = self + textField.translatesAutoresizingMaskIntoConstraints = false + textField.placeholderString = NSLocalizedString("123456", comment: "") + alert.accessoryView = textField + alert.window.initialFirstResponder = textField + + alert.addButton(withTitle: NSLocalizedString("Continue", comment: "")) + alert.addButton(withTitle: NSLocalizedString("Cancel", comment: "")) + + self.securityCodeAlert = alert + self.securityCodeTextField = textField + self.validate() + + NSRunningApplication.current.activate(options: .activateIgnoringOtherApps) + + let response = alert.runModal() + if response == .alertFirstButtonReturn + { + let code = textField.stringValue + completionHandler(code) + } + else + { + completionHandler(nil) + } + } + } + + ALTAppleAPI.shared.authenticate(appleID: appleID, password: password, anisetteData: anisetteData, verificationHandler: handleVerificationCode) { (account, session, error) in + if let account = account, let session = session + { + completionHandler(.success((account, session))) + } + else + { + completionHandler(.failure(error ?? ALTAppleAPIError(.unknown))) + } } } - func fetchTeam(for account: ALTAccount, completionHandler: @escaping (Result) -> Void) + func fetchTeam(for account: ALTAccount, session: ALTAppleAPISession, completionHandler: @escaping (Result) -> Void) { func finish(_ result: Result) { @@ -238,7 +308,7 @@ To prevent this from happening, feel free to try again with another Apple ID to } } - ALTAppleAPI.shared.fetchTeams(for: account) { (teams, error) in + ALTAppleAPI.shared.fetchTeams(for: account, session: session) { (teams, error) in do { let teams = try Result(teams, error).get() @@ -267,9 +337,9 @@ To prevent this from happening, feel free to try again with another Apple ID to } } - func fetchCertificate(for team: ALTTeam, completionHandler: @escaping (Result) -> Void) + func fetchCertificate(for team: ALTTeam, session: ALTAppleAPISession, completionHandler: @escaping (Result) -> Void) { - ALTAppleAPI.shared.fetchCertificates(for: team) { (certificates, error) in + ALTAppleAPI.shared.fetchCertificates(for: team, session: session) { (certificates, error) in do { let certificates = try Result(certificates, error).get() @@ -304,11 +374,11 @@ To prevent this from happening, feel free to try again with another Apple ID to if let certificate = certificates.first { - ALTAppleAPI.shared.revoke(certificate, for: team) { (success, error) in + ALTAppleAPI.shared.revoke(certificate, for: team, session: session) { (success, error) in do { try Result(success, error).get() - self.fetchCertificate(for: team, completionHandler: completionHandler) + self.fetchCertificate(for: team, session: session, completionHandler: completionHandler) } catch { @@ -318,13 +388,13 @@ To prevent this from happening, feel free to try again with another Apple ID to } else { - ALTAppleAPI.shared.addCertificate(machineName: "AltStore", to: team) { (certificate, error) in + ALTAppleAPI.shared.addCertificate(machineName: "AltStore", to: team, session: session) { (certificate, error) in do { let certificate = try Result(certificate, error).get() guard let privateKey = certificate.privateKey else { throw InstallError.missingPrivateKey } - ALTAppleAPI.shared.fetchCertificates(for: team) { (certificates, error) in + ALTAppleAPI.shared.fetchCertificates(for: team, session: session) { (certificates, error) in do { let certificates = try Result(certificates, error).get() @@ -357,11 +427,11 @@ To prevent this from happening, feel free to try again with another Apple ID to } } - func registerAppID(name appName: String, identifier: String, team: ALTTeam, completionHandler: @escaping (Result) -> Void) + func registerAppID(name appName: String, identifier: String, team: ALTTeam, session: ALTAppleAPISession, completionHandler: @escaping (Result) -> Void) { let bundleID = "com.\(team.identifier).\(identifier)" - ALTAppleAPI.shared.fetchAppIDs(for: team) { (appIDs, error) in + ALTAppleAPI.shared.fetchAppIDs(for: team, session: session) { (appIDs, error) in do { let appIDs = try Result(appIDs, error).get() @@ -372,7 +442,7 @@ To prevent this from happening, feel free to try again with another Apple ID to } else { - ALTAppleAPI.shared.addAppID(withName: appName, bundleIdentifier: bundleID, team: team) { (appID, error) in + ALTAppleAPI.shared.addAppID(withName: appName, bundleIdentifier: bundleID, team: team, session: session) { (appID, error) in completionHandler(Result(appID, error)) } } @@ -384,7 +454,7 @@ To prevent this from happening, feel free to try again with another Apple ID to } } - func updateFeatures(for appID: ALTAppID, app: ALTApplication, team: ALTTeam, completionHandler: @escaping (Result) -> Void) + func updateFeatures(for appID: ALTAppID, app: ALTApplication, team: ALTTeam, session: ALTAppleAPISession, completionHandler: @escaping (Result) -> Void) { let requiredFeatures = app.entitlements.compactMap { (entitlement, value) -> (ALTFeature, Any)? in guard let feature = ALTFeature(entitlement: entitlement) else { return nil } @@ -401,14 +471,14 @@ To prevent this from happening, feel free to try again with another Apple ID to let appID = appID.copy() as! ALTAppID appID.features = features - ALTAppleAPI.shared.update(appID, team: team) { (appID, error) in + ALTAppleAPI.shared.update(appID, team: team, session: session) { (appID, error) in completionHandler(Result(appID, error)) } } - func register(_ device: ALTDevice, team: ALTTeam, completionHandler: @escaping (Result) -> Void) + func register(_ device: ALTDevice, team: ALTTeam, session: ALTAppleAPISession, completionHandler: @escaping (Result) -> Void) { - ALTAppleAPI.shared.fetchDevices(for: team) { (devices, error) in + ALTAppleAPI.shared.fetchDevices(for: team, session: session) { (devices, error) in do { let devices = try Result(devices, error).get() @@ -419,7 +489,7 @@ To prevent this from happening, feel free to try again with another Apple ID to } else { - ALTAppleAPI.shared.registerDevice(name: device.name, identifier: device.identifier, team: team) { (device, error) in + ALTAppleAPI.shared.registerDevice(name: device.name, identifier: device.identifier, team: team, session: session) { (device, error) in completionHandler(Result(device, error)) } } @@ -431,9 +501,9 @@ To prevent this from happening, feel free to try again with another Apple ID to } } - func fetchProvisioningProfile(for appID: ALTAppID, team: ALTTeam, completionHandler: @escaping (Result) -> Void) + func fetchProvisioningProfile(for appID: ALTAppID, team: ALTTeam, session: ALTAppleAPISession, completionHandler: @escaping (Result) -> Void) { - ALTAppleAPI.shared.fetchProvisioningProfile(for: appID, team: team) { (profile, error) in + ALTAppleAPI.shared.fetchProvisioningProfile(for: appID, team: team, session: session) { (profile, error) in completionHandler(Result(profile, error)) } } @@ -449,7 +519,16 @@ To prevent this from happening, feel free to try again with another Apple ID to infoDictionary[kCFBundleIdentifierKey as String] = profile.bundleIdentifier infoDictionary[Bundle.Info.deviceID] = device.identifier infoDictionary[Bundle.Info.serverID] = UserDefaults.standard.serverID + infoDictionary[Bundle.Info.certificateID] = certificate.serialNumber try (infoDictionary as NSDictionary).write(to: infoPlistURL) + + if + let machineIdentifier = certificate.machineIdentifier, + let encryptedData = certificate.encryptedP12Data(withPassword: machineIdentifier) + { + let certificateURL = application.fileURL.appendingPathComponent("ALTCertificate.p12") + try encryptedData.write(to: certificateURL, options: .atomic) + } let resigner = ALTSigner(team: team, certificate: certificate) resigner.signApp(at: application.fileURL, provisioningProfiles: [profile]) { (success, error) in @@ -476,3 +555,45 @@ To prevent this from happening, feel free to try again with another Apple ID to } } } + +private var securityCodeAlertKey = 0 +private var securityCodeTextFieldKey = 0 + +extension ALTDeviceManager: NSTextFieldDelegate +{ + var securityCodeAlert: NSAlert? { + get { return objc_getAssociatedObject(self, &securityCodeAlertKey) as? NSAlert } + set { objc_setAssociatedObject(self, &securityCodeAlertKey, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC) } + } + + var securityCodeTextField: NSTextField? { + get { return objc_getAssociatedObject(self, &securityCodeTextFieldKey) as? NSTextField } + set { objc_setAssociatedObject(self, &securityCodeTextFieldKey, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC) } + } + + public func controlTextDidChange(_ obj: Notification) + { + self.validate() + } + + public func controlTextDidEndEditing(_ obj: Notification) + { + self.validate() + } + + private func validate() + { + guard let code = self.securityCodeTextField?.stringValue.trimmingCharacters(in: .whitespacesAndNewlines) else { return } + + if code.count == 6 + { + self.securityCodeAlert?.buttons.first?.isEnabled = true + } + else + { + self.securityCodeAlert?.buttons.first?.isEnabled = false + } + + self.securityCodeAlert?.layout() + } +} diff --git a/AltServer/Devices/ALTDeviceManager.h b/AltServer/Devices/ALTDeviceManager.h index 8447b57d..f70af7a3 100644 --- a/AltServer/Devices/ALTDeviceManager.h +++ b/AltServer/Devices/ALTDeviceManager.h @@ -9,8 +9,14 @@ #import #import +@class ALTWiredConnection; +@class ALTNotificationConnection; + NS_ASSUME_NONNULL_BEGIN +extern NSNotificationName const ALTDeviceManagerDeviceDidConnectNotification NS_SWIFT_NAME(deviceManagerDeviceDidConnect); +extern NSNotificationName const ALTDeviceManagerDeviceDidDisconnectNotification NS_SWIFT_NAME(deviceManagerDeviceDidDisconnect); + @interface ALTDeviceManager : NSObject @property (class, nonatomic, readonly) ALTDeviceManager *sharedManager; @@ -18,8 +24,15 @@ NS_ASSUME_NONNULL_BEGIN @property (nonatomic, readonly) NSArray *connectedDevices; @property (nonatomic, readonly) NSArray *availableDevices; +- (void)start; + +/* App Installation */ - (NSProgress *)installAppAtURL:(NSURL *)fileURL toDeviceWithUDID:(NSString *)udid completionHandler:(void (^)(BOOL success, NSError *_Nullable error))completionHandler; +/* Connections */ +- (void)startWiredConnectionToDevice:(ALTDevice *)device completionHandler:(void (^)(ALTWiredConnection *_Nullable connection, NSError *_Nullable error))completionHandler; +- (void)startNotificationConnectionToDevice:(ALTDevice *)device completionHandler:(void (^)(ALTNotificationConnection *_Nullable connection, NSError *_Nullable error))completionHandler; + @end NS_ASSUME_NONNULL_END diff --git a/AltServer/Devices/ALTDeviceManager.mm b/AltServer/Devices/ALTDeviceManager.mm index f856a183..24420458 100644 --- a/AltServer/Devices/ALTDeviceManager.mm +++ b/AltServer/Devices/ALTDeviceManager.mm @@ -7,7 +7,10 @@ // #import "ALTDeviceManager.h" -#import "NSError+ALTServerError.h" + +#import "AltKit.h" +#import "ALTWiredConnection+Private.h" +#import "ALTNotificationConnection+Private.h" #include #include @@ -17,8 +20,10 @@ #include void ALTDeviceManagerUpdateStatus(plist_t command, plist_t status, void *udid); +void ALTDeviceDidChangeConnectionStatus(const idevice_event_t *event, void *user_data); -NSErrorDomain const ALTDeviceErrorDomain = @"com.rileytestut.ALTDeviceError"; +NSNotificationName const ALTDeviceManagerDeviceDidConnectNotification = @"ALTDeviceManagerDeviceDidConnectNotification"; +NSNotificationName const ALTDeviceManagerDeviceDidDisconnectNotification = @"ALTDeviceManagerDeviceDidDisconnectNotification"; @interface ALTDeviceManager () @@ -26,6 +31,8 @@ NSErrorDomain const ALTDeviceErrorDomain = @"com.rileytestut.ALTDeviceError"; @property (nonatomic, readonly) NSMutableDictionary *installationProgress; @property (nonatomic, readonly) dispatch_queue_t installationQueue; +@property (nonatomic, readonly) NSMutableSet *cachedDevices; + @end @implementation ALTDeviceManager @@ -50,11 +57,20 @@ NSErrorDomain const ALTDeviceErrorDomain = @"com.rileytestut.ALTDeviceError"; _installationProgress = [NSMutableDictionary dictionary]; _installationQueue = dispatch_queue_create("com.rileytestut.AltServer.InstallationQueue", DISPATCH_QUEUE_SERIAL); + + _cachedDevices = [NSMutableSet set]; } return self; } +- (void)start +{ + idevice_event_subscribe(ALTDeviceDidChangeConnectionStatus, nil); +} + +#pragma mark - App Installation - + - (NSProgress *)installAppAtURL:(NSURL *)fileURL toDeviceWithUDID:(NSString *)udid completionHandler:(void (^)(BOOL, NSError * _Nullable))completionHandler { NSProgress *progress = [NSProgress discreteProgressWithTotalUnitCount:4]; @@ -109,6 +125,8 @@ NSErrorDomain const ALTDeviceErrorDomain = @"com.rileytestut.ALTDeviceError"; int code = misagent_get_status_code(mis); NSLog(@"Failed to reinstall provisioning profile %@. (%@)", provisioningProfile.UUID, @(code)); } + + plist_free(pdata); } [[NSFileManager defaultManager] removeItemAtURL:removedProfilesDirectoryURL error:nil]; @@ -279,13 +297,25 @@ NSErrorDomain const ALTDeviceErrorDomain = @"com.rileytestut.ALTDeviceError"; return finish(error); } - plist_t profiles = NULL; + plist_t rawProfiles = NULL; - if (misagent_copy_all(mis, &profiles) != MISAGENT_E_SUCCESS) + if (misagent_copy_all(mis, &rawProfiles) != MISAGENT_E_SUCCESS) { return finish([NSError errorWithDomain:AltServerErrorDomain code:ALTServerErrorConnectionFailed userInfo:nil]); } - + + // For some reason, libplist now fails to parse `rawProfiles` correctly. + // Specifically, it no longer recognizes the nodes in the plist array as "data" nodes. + // However, if we encode it as XML then decode it again, it'll work ¯\_(ツ)_/¯ + char *plistXML = nullptr; + uint32_t plistLength = 0; + plist_to_xml(rawProfiles, &plistXML, &plistLength); + + plist_t profiles = NULL; + plist_from_xml(plistXML, plistLength, &profiles); + + free(plistXML); + uint32_t profileCount = plist_array_get_size(profiles); for (int i = 0; i < profileCount; i++) { @@ -294,7 +324,7 @@ NSErrorDomain const ALTDeviceErrorDomain = @"com.rileytestut.ALTDeviceError"; { continue; } - + char *bytes = NULL; uint64_t length = 0; @@ -304,10 +334,10 @@ NSErrorDomain const ALTDeviceErrorDomain = @"com.rileytestut.ALTDeviceError"; continue; } - NSData *data = [NSData dataWithBytes:(const void *)bytes length:length]; + NSData *data = [NSData dataWithBytesNoCopy:bytes length:length freeWhenDone:YES]; ALTProvisioningProfile *provisioningProfile = [[ALTProvisioningProfile alloc] initWithData:data]; - if (![provisioningProfile.teamIdentifier isEqualToString:installationProvisioningProfile.teamIdentifier]) + if (![provisioningProfile isFreeProvisioningProfile]) { NSLog(@"Ignoring: %@ (Team: %@)", provisioningProfile.bundleIdentifier, provisioningProfile.teamIdentifier); continue; @@ -338,14 +368,17 @@ NSErrorDomain const ALTDeviceErrorDomain = @"com.rileytestut.ALTDeviceError"; if (misagent_remove(mis, provisioningProfile.UUID.UUIDString.lowercaseString.UTF8String) == MISAGENT_E_SUCCESS) { - NSLog(@"Removed provisioning profile: %@", provisioningProfile.UUID); + NSLog(@"Removed provisioning profile: %@ (Team: %@)", provisioningProfile.bundleIdentifier, provisioningProfile.teamIdentifier); } else { int code = misagent_get_status_code(mis); - NSLog(@"Failed to remove provisioning profile %@. Error Code: %@", provisioningProfile.UUID, @(code)); + NSLog(@"Failed to remove provisioning profile %@ (Team: %@). Error Code: %@", provisioningProfile.bundleIdentifier, provisioningProfile.teamIdentifier, @(code)); } } + + plist_free(rawProfiles); + plist_free(profiles); lockdownd_client_free(client); client = NULL; @@ -514,6 +547,89 @@ NSErrorDomain const ALTDeviceErrorDomain = @"com.rileytestut.ALTDeviceError"; return success; } +#pragma mark - Connections - + +- (void)startWiredConnectionToDevice:(ALTDevice *)altDevice completionHandler:(void (^)(ALTWiredConnection * _Nullable, NSError * _Nullable))completionHandler +{ + void (^finish)(ALTWiredConnection *connection, NSError *error) = ^(ALTWiredConnection *connection, NSError *error) { + if (error != nil) + { + NSLog(@"Wired Connection Error: %@", error); + } + + completionHandler(connection, error); + }; + + idevice_t device = NULL; + idevice_connection_t connection = NULL; + + /* Find Device */ + if (idevice_new_ignore_network(&device, altDevice.identifier.UTF8String) != IDEVICE_E_SUCCESS) + { + return finish(nil, [NSError errorWithDomain:AltServerErrorDomain code:ALTServerErrorDeviceNotFound userInfo:nil]); + } + + /* Connect to Listening Socket */ + if (idevice_connect(device, ALTDeviceListeningSocket, &connection) != IDEVICE_E_SUCCESS) + { + return finish(nil, [NSError errorWithDomain:AltServerErrorDomain code:ALTServerErrorConnectionFailed userInfo:nil]); + } + + idevice_free(device); + + ALTWiredConnection *wiredConnection = [[ALTWiredConnection alloc] initWithDevice:altDevice connection:connection]; + finish(wiredConnection, nil); +} + +- (void)startNotificationConnectionToDevice:(ALTDevice *)altDevice completionHandler:(void (^)(ALTNotificationConnection * _Nullable, NSError * _Nullable))completionHandler +{ + void (^finish)(ALTNotificationConnection *, NSError *) = ^(ALTNotificationConnection *connection, NSError *error) { + if (error != nil) + { + NSLog(@"Notification Connection Error: %@", error); + } + + completionHandler(connection, error); + }; + + idevice_t device = NULL; + lockdownd_client_t lockdownClient = NULL; + lockdownd_service_descriptor_t service = NULL; + + np_client_t client = NULL; + + /* Find Device */ + if (idevice_new_ignore_network(&device, altDevice.identifier.UTF8String) != IDEVICE_E_SUCCESS) + { + return finish(nil, [NSError errorWithDomain:AltServerErrorDomain code:ALTServerErrorDeviceNotFound userInfo:nil]); + } + + /* Connect to Device */ + if (lockdownd_client_new_with_handshake(device, &lockdownClient, "altserver") != LOCKDOWN_E_SUCCESS) + { + return finish(nil, [NSError errorWithDomain:AltServerErrorDomain code:ALTServerErrorConnectionFailed userInfo:nil]); + } + + /* Connect to Notification Proxy */ + if ((lockdownd_start_service(lockdownClient, "com.apple.mobile.notification_proxy", &service) != LOCKDOWN_E_SUCCESS) || service == NULL) + { + return finish(nil, [NSError errorWithDomain:AltServerErrorDomain code:ALTServerErrorConnectionFailed userInfo:nil]); + } + + /* Connect to Client */ + if (np_client_new(device, service, &client) != NP_E_SUCCESS) + { + return finish(nil, [NSError errorWithDomain:AltServerErrorDomain code:ALTServerErrorConnectionFailed userInfo:nil]); + } + + lockdownd_service_descriptor_free(service); + lockdownd_client_free(lockdownClient); + idevice_free(device); + + ALTNotificationConnection *notificationConnection = [[ALTNotificationConnection alloc] initWithDevice:altDevice client:client]; + completionHandler(notificationConnection, nil); +} + #pragma mark - Getters - - (NSArray *)connectedDevices @@ -670,3 +786,49 @@ void ALTDeviceManagerUpdateStatus(plist_t command, plist_t status, void *uuid) NSLog(@"Installation Progress: %@", @(percent)); } } + +void ALTDeviceDidChangeConnectionStatus(const idevice_event_t *event, void *user_data) +{ + ALTDevice * (^deviceForUDID)(NSString *, NSArray *) = ^ALTDevice *(NSString *udid, NSArray *devices) { + for (ALTDevice *device in devices) + { + if ([device.identifier isEqualToString:udid]) + { + return device; + } + } + + return nil; + }; + + switch (event->event) + { + case IDEVICE_DEVICE_ADD: + { + ALTDevice *device = deviceForUDID(@(event->udid), ALTDeviceManager.sharedManager.connectedDevices); + [[NSNotificationCenter defaultCenter] postNotificationName:ALTDeviceManagerDeviceDidConnectNotification object:device]; + + if (device) + { + [ALTDeviceManager.sharedManager.cachedDevices addObject:device]; + } + + break; + } + + case IDEVICE_DEVICE_REMOVE: + { + ALTDevice *device = deviceForUDID(@(event->udid), ALTDeviceManager.sharedManager.cachedDevices.allObjects); + [[NSNotificationCenter defaultCenter] postNotificationName:ALTDeviceManagerDeviceDidDisconnectNotification object:device]; + + if (device) + { + [ALTDeviceManager.sharedManager.cachedDevices removeObject:device]; + } + + break; + } + + default: break; + } +} diff --git a/AltServer/Info.plist b/AltServer/Info.plist index ef798a09..096397d2 100644 --- a/AltServer/Info.plist +++ b/AltServer/Info.plist @@ -17,9 +17,9 @@ CFBundlePackageType APPL CFBundleShortVersionString - 1.0.1 + $(MARKETING_VERSION) CFBundleVersion - 2 + $(CURRENT_PROJECT_VERSION) LSMinimumSystemVersion $(MACOSX_DEPLOYMENT_TARGET) LSUIElement @@ -30,5 +30,7 @@ Main NSPrincipalClass NSApplication + SUFeedURL + https://altstore.io/altserver/sparkle-macos.xml diff --git a/AltServer/InstallPlugin.sh b/AltServer/InstallPlugin.sh new file mode 100644 index 00000000..302da4a4 --- /dev/null +++ b/AltServer/InstallPlugin.sh @@ -0,0 +1,13 @@ +#!/bin/sh + +# InstallAltPlugin.sh +# AltStore +# +# Created by Riley Testut on 11/16/19. +# Copyright © 2019 Riley Testut. All rights reserved. + +rm -f AltPlugin.mailbundle +unzip AltPlugin.mailbundle.zip 1>/dev/null +mkdir -p /Library/Mail/Bundles +cp -r AltPlugin.mailbundle /Library/Mail/Bundles +defaults write "/Library/Preferences/com.apple.mail" EnableBundles 1 diff --git a/AltServer/UninstallPlugin.sh b/AltServer/UninstallPlugin.sh new file mode 100644 index 00000000..5d3ab257 --- /dev/null +++ b/AltServer/UninstallPlugin.sh @@ -0,0 +1,9 @@ +#!/bin/sh + +# UninstallPlugin.sh +# AltStore +# +# Created by Riley Testut on 11/16/19. +# Copyright © 2019 Riley Testut. All rights reserved. + +rm -rf /Library/Mail/Bundles/AltPlugin.mailbundle diff --git a/AltStore.xcodeproj/project.pbxproj b/AltStore.xcodeproj/project.pbxproj index d4bdbee6..8e188abd 100644 --- a/AltStore.xcodeproj/project.pbxproj +++ b/AltStore.xcodeproj/project.pbxproj @@ -3,10 +3,12 @@ archiveVersion = 1; classes = { }; - objectVersion = 50; + objectVersion = 51; objects = { /* Begin PBXBuildFile section */ + 01100C7036F0EBAC5B30984B /* libPods-AltStore.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0DE618FA97EA42C3F468D186 /* libPods-AltStore.a */; }; + A8BCEBEAC0620CF80A2FD26D /* Pods_AltServer.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = FC3822AB1C4CF1D4CDF7445D /* Pods_AltServer.framework */; }; BF0201BA22C2EFA3000B93E4 /* AltSign.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = BF5AB3A72285FE6C00DC914B /* AltSign.framework */; }; BF0201BB22C2EFA3000B93E4 /* AltSign.framework in Embed Frameworks */ = {isa = PBXBuildFile; fileRef = BF5AB3A72285FE6C00DC914B /* AltSign.framework */; settings = {ATTRIBUTES = (CodeSignOnCopy, RemoveHeadersOnCopy, ); }; }; BF0201BD22C2EFBC000B93E4 /* openssl.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = BF4713A422976CFC00784A2F /* openssl.framework */; }; @@ -17,6 +19,7 @@ BF08858322DE795100DE9F1E /* MyAppsViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF08858222DE795100DE9F1E /* MyAppsViewController.swift */; }; BF08858522DE7EC800DE9F1E /* UpdateCollectionViewCell.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF08858422DE7EC800DE9F1E /* UpdateCollectionViewCell.swift */; }; BF0C4EBD22A1BD8B009A2DD7 /* AppManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF0C4EBC22A1BD8B009A2DD7 /* AppManager.swift */; }; + BF0F5FC723F394AD0080DB64 /* AltStore3ToAltStore4.xcmappingmodel in Sources */ = {isa = PBXBuildFile; fileRef = BF0F5FC623F394AD0080DB64 /* AltStore3ToAltStore4.xcmappingmodel */; }; BF100C50232D7CD1006A8926 /* AltStoreToAltStore2.xcmappingmodel in Sources */ = {isa = PBXBuildFile; fileRef = BF100C4F232D7CD1006A8926 /* AltStoreToAltStore2.xcmappingmodel */; }; BF100C54232D7DAE006A8926 /* StoreAppPolicy.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF100C53232D7DAE006A8926 /* StoreAppPolicy.swift */; }; BF18B0F122E25DF9005C4CF5 /* ToastView.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF18B0F022E25DF9005C4CF5 /* ToastView.swift */; }; @@ -28,6 +31,7 @@ BF1E315F22A0635900370A3C /* libAltKit.a in Frameworks */ = {isa = PBXBuildFile; fileRef = BF1E315022A0616100370A3C /* libAltKit.a */; }; BF1E316022A0636400370A3C /* libAltKit.a in Frameworks */ = {isa = PBXBuildFile; fileRef = BF1E315022A0616100370A3C /* libAltKit.a */; }; BF258CE322EBAE2800023032 /* AppProtocol.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF258CE222EBAE2800023032 /* AppProtocol.swift */; }; + BF26A0E12370C5D400F53F9F /* ALTSourceUserInfoKey.m in Sources */ = {isa = PBXBuildFile; fileRef = BF26A0E02370C5D400F53F9F /* ALTSourceUserInfoKey.m */; }; BF29012F2318F6B100D88A45 /* AppBannerView.xib in Resources */ = {isa = PBXBuildFile; fileRef = BF29012E2318F6B100D88A45 /* AppBannerView.xib */; }; BF2901312318F7A800D88A45 /* AppBannerView.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF2901302318F7A800D88A45 /* AppBannerView.swift */; }; BF3D648822E79A3700E9056B /* AppPermission.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF3D648722E79A3700E9056B /* AppPermission.swift */; }; @@ -110,29 +114,46 @@ BF45884A2298D55000BD7491 /* thread.c in Sources */ = {isa = PBXBuildFile; fileRef = BF4588482298D55000BD7491 /* thread.c */; }; BF45884B2298D55000BD7491 /* thread.h in Headers */ = {isa = PBXBuildFile; fileRef = BF4588492298D55000BD7491 /* thread.h */; }; BF4588882298DD3F00BD7491 /* libxml2.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = BF4588872298DD3F00BD7491 /* libxml2.tbd */; }; - BF4713A522976D1E00784A2F /* openssl.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = BF4713A422976CFC00784A2F /* openssl.framework */; }; - BF4713A622976D1E00784A2F /* openssl.framework in Embed Frameworks */ = {isa = PBXBuildFile; fileRef = BF4713A422976CFC00784A2F /* openssl.framework */; settings = {ATTRIBUTES = (CodeSignOnCopy, RemoveHeadersOnCopy, ); }; }; + BF4C7F2523801F0800B2556E /* AltSign.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = BF9B63C5229DD44D002F0A62 /* AltSign.framework */; }; + BF4C7F27238086EB00B2556E /* InstallPlugin.sh in Resources */ = {isa = PBXBuildFile; fileRef = BF4C7F26238086EB00B2556E /* InstallPlugin.sh */; }; BF54E8212315EF0D000AE0D8 /* ALTPatreonBenefitType.m in Sources */ = {isa = PBXBuildFile; fileRef = BF54E8202315EF0D000AE0D8 /* ALTPatreonBenefitType.m */; }; - BF5AB3A82285FE7500DC914B /* AltSign.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = BF5AB3A72285FE6C00DC914B /* AltSign.framework */; }; - BF5AB3A92285FE7500DC914B /* AltSign.framework in Embed Frameworks */ = {isa = PBXBuildFile; fileRef = BF5AB3A72285FE6C00DC914B /* AltSign.framework */; settings = {ATTRIBUTES = (CodeSignOnCopy, RemoveHeadersOnCopy, ); }; }; + BF56D2AA23DF88310006506D /* AppID.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF56D2A923DF88310006506D /* AppID.swift */; }; + BF56D2AC23DF8E170006506D /* FetchAppIDsOperation.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF56D2AB23DF8E170006506D /* FetchAppIDsOperation.swift */; }; + BF56D2AF23DF9E310006506D /* AppIDsViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF56D2AE23DF9E310006506D /* AppIDsViewController.swift */; }; + BF5C5FCF237DF69100EDD0C6 /* ALTPluginService.m in Sources */ = {isa = PBXBuildFile; fileRef = BF5C5FCE237DF69100EDD0C6 /* ALTPluginService.m */; }; + BF6F439223644C6E00A0B879 /* RefreshAltStoreViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF6F439123644C6E00A0B879 /* RefreshAltStoreViewController.swift */; }; + BF718BC923C919E300A89F2D /* CFNotificationName+AltStore.m in Sources */ = {isa = PBXBuildFile; fileRef = BF718BC823C919E300A89F2D /* CFNotificationName+AltStore.m */; }; + BF718BD123C91BD300A89F2D /* ALTWiredConnection.m in Sources */ = {isa = PBXBuildFile; fileRef = BF718BD023C91BD300A89F2D /* ALTWiredConnection.m */; }; + BF718BD523C928A300A89F2D /* ALTNotificationConnection.m in Sources */ = {isa = PBXBuildFile; fileRef = BF718BD423C928A300A89F2D /* ALTNotificationConnection.m */; }; + BF718BD823C93DB700A89F2D /* AltKit.m in Sources */ = {isa = PBXBuildFile; fileRef = BF718BD723C93DB700A89F2D /* AltKit.m */; }; + BF74989B23621C0700CED65F /* ForwardingNavigationController.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF74989A23621C0700CED65F /* ForwardingNavigationController.swift */; }; BF770E5122BB1CF6002A40FE /* InstallAppOperation.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF770E5022BB1CF6002A40FE /* InstallAppOperation.swift */; }; BF770E5422BC044E002A40FE /* AppOperationContext.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF770E5322BC044E002A40FE /* AppOperationContext.swift */; }; BF770E5622BC3C03002A40FE /* Server.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF770E5522BC3C02002A40FE /* Server.swift */; }; BF770E5822BC3D0F002A40FE /* OperationGroup.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF770E5722BC3D0F002A40FE /* OperationGroup.swift */; }; BF770E6722BD57C4002A40FE /* BackgroundTaskManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF770E6622BD57C3002A40FE /* BackgroundTaskManager.swift */; }; BF770E6922BD57DD002A40FE /* Silence.m4a in Resources */ = {isa = PBXBuildFile; fileRef = BF770E6822BD57DD002A40FE /* Silence.m4a */; }; + BF7C627223DBB3B400515A2D /* AltStore2ToAltStore3.xcmappingmodel in Sources */ = {isa = PBXBuildFile; fileRef = BF7C627123DBB3B400515A2D /* AltStore2ToAltStore3.xcmappingmodel */; }; + BF7C627423DBB78C00515A2D /* InstalledAppPolicy.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF7C627323DBB78C00515A2D /* InstalledAppPolicy.swift */; }; BF8F69C222E659F700049BA1 /* AppContentViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF8F69C122E659F700049BA1 /* AppContentViewController.swift */; }; BF8F69C422E662D300049BA1 /* AppViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF8F69C322E662D300049BA1 /* AppViewController.swift */; }; + BF914C262383703800E713BA /* AltPlugin.mailbundle.zip in Resources */ = {isa = PBXBuildFile; fileRef = BF914C252383703800E713BA /* AltPlugin.mailbundle.zip */; }; + BF9A03C623C7DD0D000D08DB /* ClientConnection.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF9A03C523C7DD0D000D08DB /* ClientConnection.swift */; }; BF9ABA4522DCFF43008935CF /* BrowseViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF9ABA4422DCFF43008935CF /* BrowseViewController.swift */; }; BF9ABA4722DD0638008935CF /* BrowseCollectionViewCell.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF9ABA4622DD0638008935CF /* BrowseCollectionViewCell.swift */; }; BF9ABA4922DD0742008935CF /* ScreenshotCollectionViewCell.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF9ABA4822DD0742008935CF /* ScreenshotCollectionViewCell.swift */; }; BF9ABA4B22DD1380008935CF /* NavigationBar.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF9ABA4A22DD137F008935CF /* NavigationBar.swift */; }; BF9ABA4D22DD16DE008935CF /* PillButton.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF9ABA4C22DD16DE008935CF /* PillButton.swift */; }; BF9ABA4F22DD41A9008935CF /* UIColor+Hex.swift in Sources */ = {isa = PBXBuildFile; fileRef = BF9ABA4E22DD41A9008935CF /* UIColor+Hex.swift */; }; + BFA8172923C56042001B5953 /* ServerConnection.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFA8172823C56042001B5953 /* ServerConnection.swift */; }; + BFA8172B23C5633D001B5953 /* FetchAnisetteDataOperation.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFA8172A23C5633D001B5953 /* FetchAnisetteDataOperation.swift */; }; + BFA8172D23C5823E001B5953 /* InstalledExtension.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFA8172C23C5823E001B5953 /* InstalledExtension.swift */; }; + BFA8172F23C5831A001B5953 /* PrepareDeveloperAccountOperation.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFA8172E23C5831A001B5953 /* PrepareDeveloperAccountOperation.swift */; }; BFB11692229322E400BB457C /* DatabaseManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFB11691229322E400BB457C /* DatabaseManager.swift */; }; BFB1169B2293274D00BB457C /* JSONDecoder+ManagedObjectContext.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFB1169A2293274D00BB457C /* JSONDecoder+ManagedObjectContext.swift */; }; BFB3645A2325985F00CD0EB1 /* FindServerOperation.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFB364592325985F00CD0EB1 /* FindServerOperation.swift */; }; BFB4323F22DE852000B7F8BC /* UpdateCollectionViewCell.xib in Resources */ = {isa = PBXBuildFile; fileRef = BFB4323E22DE852000B7F8BC /* UpdateCollectionViewCell.xib */; }; + BFB49AAA23834CF900D542D9 /* ALTAnisetteData.m in Sources */ = {isa = PBXBuildFile; fileRef = BFB49AA823834CF900D542D9 /* ALTAnisetteData.m */; }; BFB6B21B23186D640022A802 /* NewsItem.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFB6B21A23186D640022A802 /* NewsItem.swift */; }; BFB6B21E231870160022A802 /* NewsViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFB6B21D231870160022A802 /* NewsViewController.swift */; }; BFB6B220231870B00022A802 /* NewsCollectionViewCell.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFB6B21F231870B00022A802 /* NewsCollectionViewCell.swift */; }; @@ -145,8 +166,6 @@ BFD247752284B9A500981D42 /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = BFD247732284B9A500981D42 /* Main.storyboard */; }; BFD247772284B9A700981D42 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = BFD247762284B9A700981D42 /* Assets.xcassets */; }; BFD2477A2284B9A700981D42 /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = BFD247782284B9A700981D42 /* LaunchScreen.storyboard */; }; - BFD247872284BB4200981D42 /* Roxas.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = BFD247862284BB3B00981D42 /* Roxas.framework */; }; - BFD247882284BB4200981D42 /* Roxas.framework in Embed Frameworks */ = {isa = PBXBuildFile; fileRef = BFD247862284BB3B00981D42 /* Roxas.framework */; settings = {ATTRIBUTES = (CodeSignOnCopy, RemoveHeadersOnCopy, ); }; }; BFD2478C2284C4C300981D42 /* AppIconImageView.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFD2478B2284C4C300981D42 /* AppIconImageView.swift */; }; BFD2478F2284C8F900981D42 /* Button.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFD2478E2284C8F900981D42 /* Button.swift */; }; BFD2479F2284FBD000981D42 /* UIColor+AltStore.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFD2479E2284FBD000981D42 /* UIColor+AltStore.swift */; }; @@ -189,6 +208,7 @@ BFD5D6F4230DDB0A007955AB /* Campaign.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFD5D6F3230DDB0A007955AB /* Campaign.swift */; }; BFD5D6F6230DDB12007955AB /* Tier.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFD5D6F5230DDB12007955AB /* Tier.swift */; }; BFD6B03322DFF20800B86064 /* MyAppsComponents.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFD6B03222DFF20800B86064 /* MyAppsComponents.swift */; }; + BFD80D572380C0F700B9C227 /* UninstallPlugin.sh in Resources */ = {isa = PBXBuildFile; fileRef = BFD80D562380C0F700B9C227 /* UninstallPlugin.sh */; }; BFDB5B1622EE90D300F74113 /* Date+RelativeDate.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFDB5B1522EE90D300F74113 /* Date+RelativeDate.swift */; }; BFDB5B2622EFBBEA00F74113 /* BrowseCollectionViewCell.xib in Resources */ = {isa = PBXBuildFile; fileRef = BFDB5B2522EFBBEA00F74113 /* BrowseCollectionViewCell.xib */; }; BFDB6A0522A9AFB2007EA6D6 /* Fetchable.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFDB6A0422A9AFB2007EA6D6 /* Fetchable.swift */; }; @@ -199,6 +219,7 @@ BFE338DD22F0E7F3002E24B9 /* Source.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFE338DC22F0E7F3002E24B9 /* Source.swift */; }; BFE338DF22F0EADB002E24B9 /* FetchSourceOperation.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFE338DE22F0EADB002E24B9 /* FetchSourceOperation.swift */; }; BFE338E822F10E56002E24B9 /* LaunchViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFE338E722F10E56002E24B9 /* LaunchViewController.swift */; }; + BFE48975238007CE003239E0 /* AnisetteDataManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFE48974238007CE003239E0 /* AnisetteDataManager.swift */; }; BFE60738231ADF49002B0E8E /* Settings.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = BFE60737231ADF49002B0E8E /* Settings.storyboard */; }; BFE6073A231ADF82002B0E8E /* SettingsViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFE60739231ADF82002B0E8E /* SettingsViewController.swift */; }; BFE6073C231AE1E7002B0E8E /* SettingsHeaderFooterView.xib in Resources */ = {isa = PBXBuildFile; fileRef = BFE6073B231AE1E7002B0E8E /* SettingsHeaderFooterView.xib */; }; @@ -208,6 +229,8 @@ BFE6326622A857C200F30809 /* Team.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFE6326522A857C100F30809 /* Team.swift */; }; BFE6326822A858F300F30809 /* Account.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFE6326722A858F300F30809 /* Account.swift */; }; BFE6326C22A86FF300F30809 /* AuthenticationOperation.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFE6326B22A86FF300F30809 /* AuthenticationOperation.swift */; }; + BFEE943F23F21BD800CDA07D /* ALTApplication+AppExtensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFEE943E23F21BD800CDA07D /* ALTApplication+AppExtensions.swift */; }; + BFEE944123F22AA100CDA07D /* AppIDComponents.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFEE944023F22AA100CDA07D /* AppIDComponents.swift */; }; BFF0B68E23219520007A79E1 /* PatreonViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFF0B68D23219520007A79E1 /* PatreonViewController.swift */; }; BFF0B69023219C6D007A79E1 /* PatreonComponents.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFF0B68F23219C6D007A79E1 /* PatreonComponents.swift */; }; BFF0B6922321A305007A79E1 /* AboutPatreonHeaderView.xib in Resources */ = {isa = PBXBuildFile; fileRef = BFF0B6912321A305007A79E1 /* AboutPatreonHeaderView.xib */; }; @@ -215,7 +238,6 @@ BFF0B696232242D3007A79E1 /* LicensesViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFF0B695232242D3007A79E1 /* LicensesViewController.swift */; }; BFF0B6982322CAB8007A79E1 /* InstructionsViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFF0B6972322CAB8007A79E1 /* InstructionsViewController.swift */; }; BFF0B69A2322D7D0007A79E1 /* UIScreen+CompactHeight.swift in Sources */ = {isa = PBXBuildFile; fileRef = BFF0B6992322D7D0007A79E1 /* UIScreen+CompactHeight.swift */; }; - DBAC68F8EC03F4A41D62EDE1 /* Pods_AltStore.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1039C07E517311FC499A0B64 /* Pods_AltStore.framework */; }; /* End PBXBuildFile section */ /* Begin PBXContainerItemProxy section */ @@ -240,6 +262,13 @@ remoteGlobalIDString = BF45872A2298D31600BD7491; remoteInfo = libimobiledevice; }; + BFBFFB262380C72F00993A4A /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = BFD247622284B9A500981D42 /* Project object */; + proxyType = 1; + remoteGlobalIDString = BF5C5FC4237DF5AE00EDD0C6; + remoteInfo = AltPlugin; + }; /* End PBXContainerItemProxy section */ /* Begin PBXCopyFilesBuildPhase section */ @@ -265,23 +294,21 @@ ); runOnlyForDeploymentPostprocessing = 0; }; - BFD247842284BB2C00981D42 /* Embed Frameworks */ = { + BF5C5FE9237E438C00EDD0C6 /* CopyFiles */ = { isa = PBXCopyFilesBuildPhase; buildActionMask = 2147483647; dstPath = ""; dstSubfolderSpec = 10; files = ( - BF4713A622976D1E00784A2F /* openssl.framework in Embed Frameworks */, - BFD247882284BB4200981D42 /* Roxas.framework in Embed Frameworks */, - BF5AB3A92285FE7500DC914B /* AltSign.framework in Embed Frameworks */, ); - name = "Embed Frameworks"; runOnlyForDeploymentPostprocessing = 0; }; /* End PBXCopyFilesBuildPhase section */ /* Begin PBXFileReference section */ - 1039C07E517311FC499A0B64 /* Pods_AltStore.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_AltStore.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + 0DE618FA97EA42C3F468D186 /* libPods-AltStore.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = "libPods-AltStore.a"; sourceTree = BUILT_PRODUCTS_DIR; }; + 11611D46F8A7C8B928E8156B /* Pods-AltServer.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-AltServer.debug.xcconfig"; path = "Target Support Files/Pods-AltServer/Pods-AltServer.debug.xcconfig"; sourceTree = ""; }; + 589BA531D903B28F292063E5 /* Pods-AltServer.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-AltServer.release.xcconfig"; path = "Target Support Files/Pods-AltServer/Pods-AltServer.release.xcconfig"; sourceTree = ""; }; A136EE677716B80768E9F0A2 /* Pods-AltStore.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-AltStore.release.xcconfig"; path = "Target Support Files/Pods-AltStore/Pods-AltStore.release.xcconfig"; sourceTree = ""; }; BF02419322F2156E00129732 /* RefreshAttempt.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RefreshAttempt.swift; sourceTree = ""; }; BF02419522F2199300129732 /* RefreshAttemptsViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RefreshAttemptsViewController.swift; sourceTree = ""; }; @@ -289,6 +316,7 @@ BF08858222DE795100DE9F1E /* MyAppsViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MyAppsViewController.swift; sourceTree = ""; }; BF08858422DE7EC800DE9F1E /* UpdateCollectionViewCell.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UpdateCollectionViewCell.swift; sourceTree = ""; }; BF0C4EBC22A1BD8B009A2DD7 /* AppManager.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = AppManager.swift; sourceTree = ""; }; + BF0F5FC623F394AD0080DB64 /* AltStore3ToAltStore4.xcmappingmodel */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcmappingmodel; path = AltStore3ToAltStore4.xcmappingmodel; sourceTree = ""; }; BF100C46232D7828006A8926 /* AltStore 2.xcdatamodel */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcdatamodel; path = "AltStore 2.xcdatamodel"; sourceTree = ""; }; BF100C4F232D7CD1006A8926 /* AltStoreToAltStore2.xcmappingmodel */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcmappingmodel; path = AltStoreToAltStore2.xcmappingmodel; sourceTree = ""; }; BF100C53232D7DAE006A8926 /* StoreAppPolicy.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = StoreAppPolicy.swift; sourceTree = ""; }; @@ -302,6 +330,8 @@ BF1E315022A0616100370A3C /* libAltKit.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libAltKit.a; sourceTree = BUILT_PRODUCTS_DIR; }; BF219A7E22CAC431007676A6 /* AltStore.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.plist.entitlements; path = AltStore.entitlements; sourceTree = ""; }; BF258CE222EBAE2800023032 /* AppProtocol.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppProtocol.swift; sourceTree = ""; }; + BF26A0DF2370C5D400F53F9F /* ALTSourceUserInfoKey.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ALTSourceUserInfoKey.h; sourceTree = ""; }; + BF26A0E02370C5D400F53F9F /* ALTSourceUserInfoKey.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = ALTSourceUserInfoKey.m; sourceTree = ""; }; BF29012E2318F6B100D88A45 /* AppBannerView.xib */ = {isa = PBXFileReference; lastKnownFileType = file.xib; path = AppBannerView.xib; sourceTree = ""; }; BF2901302318F7A800D88A45 /* AppBannerView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppBannerView.swift; sourceTree = ""; }; BF3D648722E79A3700E9056B /* AppPermission.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppPermission.swift; sourceTree = ""; }; @@ -392,17 +422,42 @@ BF4588872298DD3F00BD7491 /* libxml2.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libxml2.tbd; path = Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.14.sdk/usr/lib/libxml2.tbd; sourceTree = DEVELOPER_DIR; }; BF4588962298DE6E00BD7491 /* libzip.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; path = libzip.framework; sourceTree = BUILT_PRODUCTS_DIR; }; BF4713A422976CFC00784A2F /* openssl.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = openssl.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + BF4C7F26238086EB00B2556E /* InstallPlugin.sh */ = {isa = PBXFileReference; lastKnownFileType = text.script.sh; path = InstallPlugin.sh; sourceTree = ""; }; BF54E81F2315EF0D000AE0D8 /* ALTPatreonBenefitType.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ALTPatreonBenefitType.h; sourceTree = ""; }; BF54E8202315EF0D000AE0D8 /* ALTPatreonBenefitType.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = ALTPatreonBenefitType.m; sourceTree = ""; }; + BF56D2A823DF87570006506D /* AltStore 4.xcdatamodel */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcdatamodel; path = "AltStore 4.xcdatamodel"; sourceTree = ""; }; + BF56D2A923DF88310006506D /* AppID.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppID.swift; sourceTree = ""; }; + BF56D2AB23DF8E170006506D /* FetchAppIDsOperation.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FetchAppIDsOperation.swift; sourceTree = ""; }; + BF56D2AE23DF9E310006506D /* AppIDsViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppIDsViewController.swift; sourceTree = ""; }; BF5AB3A72285FE6C00DC914B /* AltSign.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = AltSign.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + BF5C5FC5237DF5AE00EDD0C6 /* AltPlugin.mailbundle */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = AltPlugin.mailbundle; sourceTree = BUILT_PRODUCTS_DIR; }; + BF5C5FC7237DF5AE00EDD0C6 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; + BF5C5FCD237DF69100EDD0C6 /* ALTPluginService.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ALTPluginService.h; sourceTree = ""; }; + BF5C5FCE237DF69100EDD0C6 /* ALTPluginService.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = ALTPluginService.m; sourceTree = ""; }; + BF6F439123644C6E00A0B879 /* RefreshAltStoreViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RefreshAltStoreViewController.swift; sourceTree = ""; }; + BF718BC723C919CC00A89F2D /* CFNotificationName+AltStore.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "CFNotificationName+AltStore.h"; sourceTree = ""; }; + BF718BC823C919E300A89F2D /* CFNotificationName+AltStore.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = "CFNotificationName+AltStore.m"; sourceTree = ""; }; + BF718BCF23C91BD300A89F2D /* ALTWiredConnection.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ALTWiredConnection.h; sourceTree = ""; }; + BF718BD023C91BD300A89F2D /* ALTWiredConnection.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = ALTWiredConnection.m; sourceTree = ""; }; + BF718BD223C91C7000A89F2D /* ALTWiredConnection+Private.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "ALTWiredConnection+Private.h"; sourceTree = ""; }; + BF718BD323C928A300A89F2D /* ALTNotificationConnection.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ALTNotificationConnection.h; sourceTree = ""; }; + BF718BD423C928A300A89F2D /* ALTNotificationConnection.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = ALTNotificationConnection.m; sourceTree = ""; }; + BF718BD623C92B3700A89F2D /* ALTNotificationConnection+Private.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "ALTNotificationConnection+Private.h"; sourceTree = ""; }; + BF718BD723C93DB700A89F2D /* AltKit.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = AltKit.m; sourceTree = ""; }; + BF74989A23621C0700CED65F /* ForwardingNavigationController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ForwardingNavigationController.swift; sourceTree = ""; }; BF770E5022BB1CF6002A40FE /* InstallAppOperation.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = InstallAppOperation.swift; sourceTree = ""; }; BF770E5322BC044E002A40FE /* AppOperationContext.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppOperationContext.swift; sourceTree = ""; }; BF770E5522BC3C02002A40FE /* Server.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Server.swift; sourceTree = ""; }; BF770E5722BC3D0F002A40FE /* OperationGroup.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = OperationGroup.swift; sourceTree = ""; }; BF770E6622BD57C3002A40FE /* BackgroundTaskManager.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = BackgroundTaskManager.swift; sourceTree = ""; }; BF770E6822BD57DD002A40FE /* Silence.m4a */ = {isa = PBXFileReference; lastKnownFileType = file; path = Silence.m4a; sourceTree = ""; }; + BF7C627023DBB33300515A2D /* AltStore 3.xcdatamodel */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcdatamodel; path = "AltStore 3.xcdatamodel"; sourceTree = ""; }; + BF7C627123DBB3B400515A2D /* AltStore2ToAltStore3.xcmappingmodel */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcmappingmodel; path = AltStore2ToAltStore3.xcmappingmodel; sourceTree = ""; }; + BF7C627323DBB78C00515A2D /* InstalledAppPolicy.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = InstalledAppPolicy.swift; sourceTree = ""; }; BF8F69C122E659F700049BA1 /* AppContentViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppContentViewController.swift; sourceTree = ""; }; BF8F69C322E662D300049BA1 /* AppViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppViewController.swift; sourceTree = ""; }; + BF914C252383703800E713BA /* AltPlugin.mailbundle.zip */ = {isa = PBXFileReference; lastKnownFileType = archive.zip; path = AltPlugin.mailbundle.zip; sourceTree = ""; }; + BF9A03C523C7DD0D000D08DB /* ClientConnection.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ClientConnection.swift; sourceTree = ""; }; BF9ABA4422DCFF43008935CF /* BrowseViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BrowseViewController.swift; sourceTree = ""; }; BF9ABA4622DD0638008935CF /* BrowseCollectionViewCell.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BrowseCollectionViewCell.swift; sourceTree = ""; }; BF9ABA4822DD0742008935CF /* ScreenshotCollectionViewCell.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ScreenshotCollectionViewCell.swift; sourceTree = ""; }; @@ -410,11 +465,17 @@ BF9ABA4C22DD16DE008935CF /* PillButton.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PillButton.swift; sourceTree = ""; }; BF9ABA4E22DD41A9008935CF /* UIColor+Hex.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "UIColor+Hex.swift"; sourceTree = ""; }; BF9B63C5229DD44D002F0A62 /* AltSign.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; path = AltSign.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + BFA8172823C56042001B5953 /* ServerConnection.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ServerConnection.swift; sourceTree = ""; }; + BFA8172A23C5633D001B5953 /* FetchAnisetteDataOperation.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FetchAnisetteDataOperation.swift; sourceTree = ""; }; + BFA8172C23C5823E001B5953 /* InstalledExtension.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = InstalledExtension.swift; sourceTree = ""; }; + BFA8172E23C5831A001B5953 /* PrepareDeveloperAccountOperation.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PrepareDeveloperAccountOperation.swift; sourceTree = ""; }; BFB11691229322E400BB457C /* DatabaseManager.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DatabaseManager.swift; sourceTree = ""; }; BFB1169A2293274D00BB457C /* JSONDecoder+ManagedObjectContext.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = "JSONDecoder+ManagedObjectContext.swift"; sourceTree = ""; }; BFB1169C22932DB100BB457C /* apps.json */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.json; path = apps.json; sourceTree = ""; }; BFB364592325985F00CD0EB1 /* FindServerOperation.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FindServerOperation.swift; sourceTree = ""; }; BFB4323E22DE852000B7F8BC /* UpdateCollectionViewCell.xib */ = {isa = PBXFileReference; lastKnownFileType = file.xib; path = UpdateCollectionViewCell.xib; sourceTree = ""; }; + BFB49AA823834CF900D542D9 /* ALTAnisetteData.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = ALTAnisetteData.m; path = "Dependencies/AltSign/AltSign/Model/Apple API/ALTAnisetteData.m"; sourceTree = SOURCE_ROOT; }; + BFB49AA923834CF900D542D9 /* ALTAnisetteData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ALTAnisetteData.h; path = "Dependencies/AltSign/AltSign/Model/Apple API/ALTAnisetteData.h"; sourceTree = SOURCE_ROOT; }; BFB6B21A23186D640022A802 /* NewsItem.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NewsItem.swift; sourceTree = ""; }; BFB6B21D231870160022A802 /* NewsViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NewsViewController.swift; sourceTree = ""; }; BFB6B21F231870B00022A802 /* NewsCollectionViewCell.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NewsCollectionViewCell.swift; sourceTree = ""; }; @@ -474,6 +535,7 @@ BFD5D6F3230DDB0A007955AB /* Campaign.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Campaign.swift; sourceTree = ""; }; BFD5D6F5230DDB12007955AB /* Tier.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Tier.swift; sourceTree = ""; }; BFD6B03222DFF20800B86064 /* MyAppsComponents.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MyAppsComponents.swift; sourceTree = ""; }; + BFD80D562380C0F700B9C227 /* UninstallPlugin.sh */ = {isa = PBXFileReference; lastKnownFileType = text.script.sh; path = UninstallPlugin.sh; sourceTree = ""; }; BFDB5B1522EE90D300F74113 /* Date+RelativeDate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "Date+RelativeDate.swift"; sourceTree = ""; }; BFDB5B2522EFBBEA00F74113 /* BrowseCollectionViewCell.xib */ = {isa = PBXFileReference; lastKnownFileType = file.xib; path = BrowseCollectionViewCell.xib; sourceTree = ""; }; BFDB6A0422A9AFB2007EA6D6 /* Fetchable.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Fetchable.swift; sourceTree = ""; }; @@ -484,6 +546,7 @@ BFE338DC22F0E7F3002E24B9 /* Source.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Source.swift; sourceTree = ""; }; BFE338DE22F0EADB002E24B9 /* FetchSourceOperation.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FetchSourceOperation.swift; sourceTree = ""; }; BFE338E722F10E56002E24B9 /* LaunchViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LaunchViewController.swift; sourceTree = ""; }; + BFE48974238007CE003239E0 /* AnisetteDataManager.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AnisetteDataManager.swift; sourceTree = ""; }; BFE60737231ADF49002B0E8E /* Settings.storyboard */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; path = Settings.storyboard; sourceTree = ""; }; BFE60739231ADF82002B0E8E /* SettingsViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SettingsViewController.swift; sourceTree = ""; }; BFE6073B231AE1E7002B0E8E /* SettingsHeaderFooterView.xib */ = {isa = PBXFileReference; lastKnownFileType = file.xib; path = SettingsHeaderFooterView.xib; sourceTree = ""; }; @@ -493,6 +556,8 @@ BFE6326522A857C100F30809 /* Team.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Team.swift; sourceTree = ""; }; BFE6326722A858F300F30809 /* Account.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Account.swift; sourceTree = ""; }; BFE6326B22A86FF300F30809 /* AuthenticationOperation.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AuthenticationOperation.swift; sourceTree = ""; }; + BFEE943E23F21BD800CDA07D /* ALTApplication+AppExtensions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = "ALTApplication+AppExtensions.swift"; sourceTree = ""; }; + BFEE944023F22AA100CDA07D /* AppIDComponents.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppIDComponents.swift; sourceTree = ""; }; BFF0B68D23219520007A79E1 /* PatreonViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PatreonViewController.swift; sourceTree = ""; }; BFF0B68F23219C6D007A79E1 /* PatreonComponents.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PatreonComponents.swift; sourceTree = ""; }; BFF0B6912321A305007A79E1 /* AboutPatreonHeaderView.xib */ = {isa = PBXFileReference; lastKnownFileType = file.xib; path = AboutPatreonHeaderView.xib; sourceTree = ""; }; @@ -516,6 +581,7 @@ isa = PBXFrameworksBuildPhase; buildActionMask = 2147483647; files = ( + BF4C7F2523801F0800B2556E /* AltSign.framework in Frameworks */, ); runOnlyForDeploymentPostprocessing = 0; }; @@ -529,6 +595,14 @@ BF4588472298D4B000BD7491 /* libimobiledevice.a in Frameworks */, BF0201BD22C2EFBC000B93E4 /* openssl.framework in Frameworks */, BF0201BA22C2EFA3000B93E4 /* AltSign.framework in Frameworks */, + A8BCEBEAC0620CF80A2FD26D /* Pods_AltServer.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + BF5C5FC2237DF5AE00EDD0C6 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( ); runOnlyForDeploymentPostprocessing = 0; }; @@ -537,10 +611,7 @@ buildActionMask = 2147483647; files = ( BF1E316022A0636400370A3C /* libAltKit.a in Frameworks */, - BF4713A522976D1E00784A2F /* openssl.framework in Frameworks */, - BFD247872284BB4200981D42 /* Roxas.framework in Frameworks */, - BF5AB3A82285FE7500DC914B /* AltSign.framework in Frameworks */, - DBAC68F8EC03F4A41D62EDE1 /* Pods_AltStore.framework in Frameworks */, + 01100C7036F0EBAC5B30984B /* libPods-AltStore.a in Frameworks */, ); runOnlyForDeploymentPostprocessing = 0; }; @@ -552,6 +623,8 @@ children = ( EA79A60285C6AF5848AA16E9 /* Pods-AltStore.debug.xcconfig */, A136EE677716B80768E9F0A2 /* Pods-AltStore.release.xcconfig */, + 11611D46F8A7C8B928E8156B /* Pods-AltServer.debug.xcconfig */, + 589BA531D903B28F292063E5 /* Pods-AltServer.release.xcconfig */, ); path = Pods; sourceTree = ""; @@ -577,6 +650,8 @@ isa = PBXGroup; children = ( BF100C4F232D7CD1006A8926 /* AltStoreToAltStore2.xcmappingmodel */, + BF7C627123DBB3B400515A2D /* AltStore2ToAltStore3.xcmappingmodel */, + BF0F5FC623F394AD0080DB64 /* AltStore3ToAltStore4.xcmappingmodel */, ); path = "Mapping Models"; sourceTree = ""; @@ -585,6 +660,7 @@ isa = PBXGroup; children = ( BF100C53232D7DAE006A8926 /* StoreAppPolicy.swift */, + BF7C627323DBB78C00515A2D /* InstalledAppPolicy.swift */, ); path = Policies; sourceTree = ""; @@ -593,11 +669,14 @@ isa = PBXGroup; children = ( BFD52BD222A06EFB000B7ED1 /* AltKit.h */, + BF718BD723C93DB700A89F2D /* AltKit.m */, BFBAC8852295C90300587369 /* Result+Conveniences.swift */, BF1E314122A05D4C00370A3C /* Bundle+AltStore.swift */, BF1E3128229F474900370A3C /* ServerProtocol.swift */, BF1E314822A060F400370A3C /* NSError+ALTServerError.h */, BF1E314922A060F400370A3C /* NSError+ALTServerError.m */, + BF718BC723C919CC00A89F2D /* CFNotificationName+AltStore.h */, + BF718BC823C919E300A89F2D /* CFNotificationName+AltStore.m */, ); path = AltKit; sourceTree = ""; @@ -609,6 +688,8 @@ BF3D648C22E79AC800E9056B /* ALTAppPermission.m */, BF54E81F2315EF0D000AE0D8 /* ALTPatreonBenefitType.h */, BF54E8202315EF0D000AE0D8 /* ALTPatreonBenefitType.m */, + BF26A0DF2370C5D400F53F9F /* ALTSourceUserInfoKey.h */, + BF26A0E02370C5D400F53F9F /* ALTSourceUserInfoKey.m */, BF41B807233433C100C593A3 /* LoadingState.swift */, ); path = Types; @@ -630,6 +711,7 @@ children = ( BF45868F229872EA00BD7491 /* AppDelegate.swift */, BF458695229872EA00BD7491 /* Main.storyboard */, + BFE48974238007CE003239E0 /* AnisetteDataManager.swift */, BF703195229F36FF006E110F /* Devices */, BFD52BDC22A0A659000B7ED1 /* Connections */, BF055B4A233B528B0086DEA9 /* Extensions */, @@ -778,10 +860,34 @@ name = libcnary; sourceTree = ""; }; + BF56D2AD23DF9E170006506D /* App IDs */ = { + isa = PBXGroup; + children = ( + BF56D2AE23DF9E310006506D /* AppIDsViewController.swift */, + BFEE944023F22AA100CDA07D /* AppIDComponents.swift */, + ); + path = "App IDs"; + sourceTree = ""; + }; + BF5C5FC6237DF5AE00EDD0C6 /* AltPlugin */ = { + isa = PBXGroup; + children = ( + BF5C5FCD237DF69100EDD0C6 /* ALTPluginService.h */, + BF5C5FCE237DF69100EDD0C6 /* ALTPluginService.m */, + BFB49AA923834CF900D542D9 /* ALTAnisetteData.h */, + BFB49AA823834CF900D542D9 /* ALTAnisetteData.m */, + BF5C5FC7237DF5AE00EDD0C6 /* Info.plist */, + ); + path = AltPlugin; + sourceTree = ""; + }; BF703194229F36F6006E110F /* Resources */ = { isa = PBXGroup; children = ( BF458693229872EA00BD7491 /* Assets.xcassets */, + BF914C252383703800E713BA /* AltPlugin.mailbundle.zip */, + BF4C7F26238086EB00B2556E /* InstallPlugin.sh */, + BFD80D562380C0F700B9C227 /* UninstallPlugin.sh */, ); name = Resources; sourceTree = ""; @@ -843,6 +949,7 @@ children = ( BFD52BD322A0800A000B7ED1 /* ServerManager.swift */, BF770E5522BC3C02002A40FE /* Server.swift */, + BFA8172823C56042001B5953 /* ServerConnection.swift */, ); path = Server; sourceTree = ""; @@ -854,6 +961,7 @@ BF45868E229872EA00BD7491 /* AltServer */, BF1E315122A0616100370A3C /* AltKit */, BF45872C2298D31600BD7491 /* libimobiledevice */, + BF5C5FC6237DF5AE00EDD0C6 /* AltPlugin */, BFD247852284BB3300981D42 /* Frameworks */, BFD2476B2284B9A500981D42 /* Products */, 4460E048E3AC1C9708C4FA33 /* Pods */, @@ -867,6 +975,7 @@ BF45868D229872EA00BD7491 /* AltServer.app */, BF45872B2298D31600BD7491 /* libimobiledevice.a */, BF1E315022A0616100370A3C /* libAltKit.a */, + BF5C5FC5237DF5AE00EDD0C6 /* AltPlugin.mailbundle */, ); name = Products; sourceTree = ""; @@ -887,6 +996,7 @@ BFDB69FB22A9A7A6007EA6D6 /* Settings */, BFD5D6E6230CC94B007955AB /* Patreon */, BFD2478A2284C49000981D42 /* Managing Apps */, + BF56D2AD23DF9E170006506D /* App IDs */, BFC51D7922972F1F00388324 /* Server */, BFD247982284D7FC00981D42 /* Model */, BFDB6A0922AAEDA1007EA6D6 /* Operations */, @@ -911,8 +1021,8 @@ BFD247862284BB3B00981D42 /* Roxas.framework */, BF5AB3A72285FE6C00DC914B /* AltSign.framework */, BF4713A422976CFC00784A2F /* openssl.framework */, - 1039C07E517311FC499A0B64 /* Pods_AltStore.framework */, FC3822AB1C4CF1D4CDF7445D /* Pods_AltServer.framework */, + 0DE618FA97EA42C3F468D186 /* libPods-AltStore.a */, ); name = Frameworks; sourceTree = ""; @@ -929,6 +1039,7 @@ isa = PBXGroup; children = ( BFD2478B2284C4C300981D42 /* AppIconImageView.swift */, + BF74989A23621C0700CED65F /* ForwardingNavigationController.swift */, BFD2478E2284C8F900981D42 /* Button.swift */, BF43002D22A714AF0051E2BC /* Keychain.swift */, BF770E6622BD57C3002A40FE /* BackgroundTaskManager.swift */, @@ -969,8 +1080,10 @@ BFB11691229322E400BB457C /* DatabaseManager.swift */, BF3D64A122E8031100E9056B /* MergePolicy.swift */, BFE6326722A858F300F30809 /* Account.swift */, + BF56D2A923DF88310006506D /* AppID.swift */, BF3D648722E79A3700E9056B /* AppPermission.swift */, BFBBE2E022931F81002097FA /* InstalledApp.swift */, + BFA8172C23C5823E001B5953 /* InstalledExtension.swift */, BFB6B21A23186D640022A802 /* NewsItem.swift */, BFD5D6E9230CCAE5007955AB /* PatreonAccount.swift */, BF02419322F2156E00129732 /* RefreshAttempt.swift */, @@ -991,6 +1104,7 @@ BF9ABA4E22DD41A9008935CF /* UIColor+Hex.swift */, BFDB5B1522EE90D300F74113 /* Date+RelativeDate.swift */, BFF0B6992322D7D0007A79E1 /* UIScreen+CompactHeight.swift */, + BFEE943E23F21BD800CDA07D /* ALTApplication+AppExtensions.swift */, ); path = Extensions; sourceTree = ""; @@ -999,6 +1113,13 @@ isa = PBXGroup; children = ( BF1E3129229F474900370A3C /* ConnectionManager.swift */, + BF9A03C523C7DD0D000D08DB /* ClientConnection.swift */, + BF718BCF23C91BD300A89F2D /* ALTWiredConnection.h */, + BF718BD223C91C7000A89F2D /* ALTWiredConnection+Private.h */, + BF718BD023C91BD300A89F2D /* ALTWiredConnection.m */, + BF718BD323C928A300A89F2D /* ALTNotificationConnection.h */, + BF718BD623C92B3700A89F2D /* ALTNotificationConnection+Private.h */, + BF718BD423C928A300A89F2D /* ALTNotificationConnection.m */, ); path = Connections; sourceTree = ""; @@ -1050,11 +1171,14 @@ BF770E5322BC044E002A40FE /* AppOperationContext.swift */, BFE6326B22A86FF300F30809 /* AuthenticationOperation.swift */, BFB364592325985F00CD0EB1 /* FindServerOperation.swift */, + BFA8172E23C5831A001B5953 /* PrepareDeveloperAccountOperation.swift */, BFC1F38C22AEE3A4003AC21A /* DownloadAppOperation.swift */, BFDB6A0722AAED73007EA6D6 /* ResignAppOperation.swift */, BFDB6A0E22AB2776007EA6D6 /* SendAppOperation.swift */, BF770E5022BB1CF6002A40FE /* InstallAppOperation.swift */, BFE338DE22F0EADB002E24B9 /* FetchSourceOperation.swift */, + BFA8172A23C5633D001B5953 /* FetchAnisetteDataOperation.swift */, + BF56D2AB23DF8E170006506D /* FetchAppIDsOperation.swift */, ); path = Operations; sourceTree = ""; @@ -1065,6 +1189,7 @@ BFE6325922A83BEB00F30809 /* Authentication.storyboard */, BFF0B6932321CB85007A79E1 /* AuthenticationViewController.swift */, BFF0B6972322CAB8007A79E1 /* InstructionsViewController.swift */, + BF6F439123644C6E00A0B879 /* RefreshAltStoreViewController.swift */, ); path = Authentication; sourceTree = ""; @@ -1141,15 +1266,19 @@ isa = PBXNativeTarget; buildConfigurationList = BF45869A229872EA00BD7491 /* Build configuration list for PBXNativeTarget "AltServer" */; buildPhases = ( + FACBF95CCAAAB7121E1D92C8 /* [CP] Check Pods Manifest.lock */, BF458689229872EA00BD7491 /* Sources */, BF45868B229872EA00BD7491 /* Resources */, BF4588462298D4AA00BD7491 /* Frameworks */, BF0201BC22C2EFA3000B93E4 /* Embed Frameworks */, BF7FDA2C23203B6B00B5D3A4 /* Copy Launcher App */, + 98BF22D155DBAEA97544E3E6 /* [CP] Embed Pods Frameworks */, + BF914C242383659400E713BA /* Sign Frameworks */, ); buildRules = ( ); dependencies = ( + BFBFFB272380C72F00993A4A /* PBXTargetDependency */, BF1E315E22A0621F00370A3C /* PBXTargetDependency */, BF4588452298D48B00BD7491 /* PBXTargetDependency */, ); @@ -1175,6 +1304,24 @@ productReference = BF45872B2298D31600BD7491 /* libimobiledevice.a */; productType = "com.apple.product-type.library.static"; }; + BF5C5FC4237DF5AE00EDD0C6 /* AltPlugin */ = { + isa = PBXNativeTarget; + buildConfigurationList = BF5C5FC8237DF5AE00EDD0C6 /* Build configuration list for PBXNativeTarget "AltPlugin" */; + buildPhases = ( + BF5C5FC1237DF5AE00EDD0C6 /* Sources */, + BF5C5FC2237DF5AE00EDD0C6 /* Frameworks */, + BF5C5FC3237DF5AE00EDD0C6 /* Resources */, + BF5C5FE9237E438C00EDD0C6 /* CopyFiles */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = AltPlugin; + productName = AltPlugin; + productReference = BF5C5FC5237DF5AE00EDD0C6 /* AltPlugin.mailbundle */; + productType = "com.apple.product-type.bundle"; + }; BFD247692284B9A500981D42 /* AltStore */ = { isa = PBXNativeTarget; buildConfigurationList = BFD2477E2284B9A700981D42 /* Build configuration list for PBXNativeTarget "AltStore" */; @@ -1183,8 +1330,7 @@ BFD247662284B9A500981D42 /* Sources */, BFD247672284B9A500981D42 /* Frameworks */, BFD247682284B9A500981D42 /* Resources */, - BFD247842284BB2C00981D42 /* Embed Frameworks */, - B8F37E08B55D2C9C4E2B1B4E /* [CP] Embed Pods Frameworks */, + 8C9013C41DD92A1476195C0E /* [CP] Copy Pods Resources */, ); buildRules = ( ); @@ -1202,7 +1348,7 @@ BFD247622284B9A500981D42 /* Project object */ = { isa = PBXProject; attributes = { - LastSwiftUpdateCheck = 1020; + LastSwiftUpdateCheck = 1120; LastUpgradeCheck = 1020; ORGANIZATIONNAME = "Riley Testut"; TargetAttributes = { @@ -1224,6 +1370,10 @@ BF45872A2298D31600BD7491 = { CreatedOnToolsVersion = 10.2.1; }; + BF5C5FC4237DF5AE00EDD0C6 = { + CreatedOnToolsVersion = 11.2; + LastSwiftMigration = 1120; + }; BFD247692284B9A500981D42 = { CreatedOnToolsVersion = 10.2.1; LastSwiftMigration = 1020; @@ -1255,6 +1405,7 @@ BF45868C229872EA00BD7491 /* AltServer */, BF1E314F22A0616100370A3C /* AltKit */, BF45872A2298D31600BD7491 /* libimobiledevice */, + BF5C5FC4237DF5AE00EDD0C6 /* AltPlugin */, ); }; /* End PBXProject section */ @@ -1264,8 +1415,18 @@ isa = PBXResourcesBuildPhase; buildActionMask = 2147483647; files = ( + BF914C262383703800E713BA /* AltPlugin.mailbundle.zip in Resources */, + BFD80D572380C0F700B9C227 /* UninstallPlugin.sh in Resources */, BF458694229872EA00BD7491 /* Assets.xcassets in Resources */, BF458697229872EA00BD7491 /* Main.storyboard in Resources */, + BF4C7F27238086EB00B2556E /* InstallPlugin.sh in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + BF5C5FC3237DF5AE00EDD0C6 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( ); runOnlyForDeploymentPostprocessing = 0; }; @@ -1291,28 +1452,38 @@ /* End PBXResourcesBuildPhase section */ /* Begin PBXShellScriptBuildPhase section */ - B8F37E08B55D2C9C4E2B1B4E /* [CP] Embed Pods Frameworks */ = { + 8C9013C41DD92A1476195C0E /* [CP] Copy Pods Resources */ = { isa = PBXShellScriptBuildPhase; buildActionMask = 2147483647; files = ( ); inputFileListPaths = ( + "${PODS_ROOT}/Target Support Files/Pods-AltStore/Pods-AltStore-resources-${CONFIGURATION}-input-files.xcfilelist", ); - inputPaths = ( - "${PODS_ROOT}/Target Support Files/Pods-AltStore/Pods-AltStore-frameworks.sh", - "${BUILT_PRODUCTS_DIR}/KeychainAccess/KeychainAccess.framework", - "${BUILT_PRODUCTS_DIR}/Nuke/Nuke.framework", - ); - name = "[CP] Embed Pods Frameworks"; + name = "[CP] Copy Pods Resources"; outputFileListPaths = ( - ); - outputPaths = ( - "${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/KeychainAccess.framework", - "${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}/Nuke.framework", + "${PODS_ROOT}/Target Support Files/Pods-AltStore/Pods-AltStore-resources-${CONFIGURATION}-output-files.xcfilelist", ); runOnlyForDeploymentPostprocessing = 0; shellPath = /bin/sh; - shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-AltStore/Pods-AltStore-frameworks.sh\"\n"; + shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-AltStore/Pods-AltStore-resources.sh\"\n"; + showEnvVarsInLog = 0; + }; + 98BF22D155DBAEA97544E3E6 /* [CP] Embed Pods Frameworks */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + "${PODS_ROOT}/Target Support Files/Pods-AltServer/Pods-AltServer-frameworks-${CONFIGURATION}-input-files.xcfilelist", + ); + name = "[CP] Embed Pods Frameworks"; + outputFileListPaths = ( + "${PODS_ROOT}/Target Support Files/Pods-AltServer/Pods-AltServer-frameworks-${CONFIGURATION}-output-files.xcfilelist", + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-AltServer/Pods-AltServer-frameworks.sh\"\n"; showEnvVarsInLog = 0; }; BF7FDA2C23203B6B00B5D3A4 /* Copy Launcher App */ = { @@ -1333,6 +1504,46 @@ shellPath = /bin/sh; shellScript = "\"${PROJECT_DIR}/Carthage/Build/Mac/LaunchAtLogin.framework/Resources/copy-helper.sh\"\n"; }; + BF914C242383659400E713BA /* Sign Frameworks */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + ); + name = "Sign Frameworks"; + outputFileListPaths = ( + ); + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "LOCATION=\"${BUILT_PRODUCTS_DIR}\"/\"${FRAMEWORKS_FOLDER_PATH}\"\nIDENTITY=${EXPANDED_CODE_SIGN_IDENTITY_NAME}\n\ncodesign --verbose --force --deep -o runtime --sign \"$IDENTITY\" \"$LOCATION/Sparkle.framework/Versions/A/Resources/AutoUpdate.app\"\ncodesign --verbose --force -o runtime --sign \"$IDENTITY\" \"$LOCATION/Sparkle.framework/Versions/A\"\n"; + }; + FACBF95CCAAAB7121E1D92C8 /* [CP] Check Pods Manifest.lock */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + "${PODS_PODFILE_DIR_PATH}/Podfile.lock", + "${PODS_ROOT}/Manifest.lock", + ); + name = "[CP] Check Pods Manifest.lock"; + outputFileListPaths = ( + ); + outputPaths = ( + "$(DERIVED_FILE_DIR)/Pods-AltServer-checkManifestLockResult.txt", + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n # print error to STDERR\n echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n"; + showEnvVarsInLog = 0; + }; FFB93342C7EB2021A1FFFB6A /* [CP] Check Pods Manifest.lock */ = { isa = PBXShellScriptBuildPhase; buildActionMask = 2147483647; @@ -1362,9 +1573,11 @@ isa = PBXSourcesBuildPhase; buildActionMask = 2147483647; files = ( + BF718BD823C93DB700A89F2D /* AltKit.m in Sources */, BF1E315A22A0620000370A3C /* NSError+ALTServerError.m in Sources */, BF1E315922A061FB00370A3C /* Bundle+AltStore.swift in Sources */, BF1E315822A061F900370A3C /* Result+Conveniences.swift in Sources */, + BF718BC923C919E300A89F2D /* CFNotificationName+AltStore.m in Sources */, BF1E315722A061F500370A3C /* ServerProtocol.swift in Sources */, ); runOnlyForDeploymentPostprocessing = 0; @@ -1374,10 +1587,14 @@ buildActionMask = 2147483647; files = ( BF3F786422CAA41E008FBD20 /* ALTDeviceManager+Installation.swift in Sources */, + BF718BD523C928A300A89F2D /* ALTNotificationConnection.m in Sources */, BF1E312B229F474900370A3C /* ConnectionManager.swift in Sources */, + BF9A03C623C7DD0D000D08DB /* ClientConnection.swift in Sources */, + BF718BD123C91BD300A89F2D /* ALTWiredConnection.m in Sources */, BF458690229872EA00BD7491 /* AppDelegate.swift in Sources */, BF4586C52298CDB800BD7491 /* ALTDeviceManager.mm in Sources */, BF0241AA22F29CCD00129732 /* UserDefaults+AltServer.swift in Sources */, + BFE48975238007CE003239E0 /* AnisetteDataManager.swift in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; @@ -1442,16 +1659,29 @@ ); runOnlyForDeploymentPostprocessing = 0; }; + BF5C5FC1237DF5AE00EDD0C6 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + BFB49AAA23834CF900D542D9 /* ALTAnisetteData.m in Sources */, + BF5C5FCF237DF69100EDD0C6 /* ALTPluginService.m in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; BFD247662284B9A500981D42 /* Sources */ = { isa = PBXSourcesBuildPhase; buildActionMask = 2147483647; files = ( BFDB6A0F22AB2776007EA6D6 /* SendAppOperation.swift in Sources */, BFDB6A0D22AAFC1A007EA6D6 /* OperationError.swift in Sources */, + BF74989B23621C0700CED65F /* ForwardingNavigationController.swift in Sources */, BF3D649D22E7AC1B00E9056B /* PermissionPopoverViewController.swift in Sources */, BFD2478F2284C8F900981D42 /* Button.swift in Sources */, BFD5D6F6230DDB12007955AB /* Tier.swift in Sources */, BFB11692229322E400BB457C /* DatabaseManager.swift in Sources */, + BF56D2AC23DF8E170006506D /* FetchAppIDsOperation.swift in Sources */, + BFEE944123F22AA100CDA07D /* AppIDComponents.swift in Sources */, + BF26A0E12370C5D400F53F9F /* ALTSourceUserInfoKey.m in Sources */, BFC1F38D22AEE3A4003AC21A /* DownloadAppOperation.swift in Sources */, BF54E8212315EF0D000AE0D8 /* ALTPatreonBenefitType.m in Sources */, BFBBE2E122931F81002097FA /* InstalledApp.swift in Sources */, @@ -1463,6 +1693,7 @@ BFD5D6F4230DDB0A007955AB /* Campaign.swift in Sources */, BFB6B21B23186D640022A802 /* NewsItem.swift in Sources */, BFF0B6982322CAB8007A79E1 /* InstructionsViewController.swift in Sources */, + BFA8172D23C5823E001B5953 /* InstalledExtension.swift in Sources */, BFD5D6E8230CC961007955AB /* PatreonAPI.swift in Sources */, BF9ABA4522DCFF43008935CF /* BrowseViewController.swift in Sources */, BF43002E22A714AF0051E2BC /* Keychain.swift in Sources */, @@ -1474,6 +1705,7 @@ BFD5D6EA230CCAE5007955AB /* PatreonAccount.swift in Sources */, BFE6326822A858F300F30809 /* Account.swift in Sources */, BFE6326622A857C200F30809 /* Team.swift in Sources */, + BFEE943F23F21BD800CDA07D /* ALTApplication+AppExtensions.swift in Sources */, BFD2476E2284B9A500981D42 /* AppDelegate.swift in Sources */, BF41B806233423AE00C593A3 /* TabBarController.swift in Sources */, BFDB6A0B22AAEDB7007EA6D6 /* Operation.swift in Sources */, @@ -1482,9 +1714,12 @@ BF100C50232D7CD1006A8926 /* AltStoreToAltStore2.xcmappingmodel in Sources */, BF3D64B022E8D4B800E9056B /* AppContentViewControllerCells.swift in Sources */, BFBBE2DD22931B20002097FA /* AltStore.xcdatamodeld in Sources */, + BF56D2AA23DF88310006506D /* AppID.swift in Sources */, BF02419422F2156E00129732 /* RefreshAttempt.swift in Sources */, + BF6F439223644C6E00A0B879 /* RefreshAltStoreViewController.swift in Sources */, BFE60742231B07E6002B0E8E /* SettingsHeaderFooterView.swift in Sources */, BFE338E822F10E56002E24B9 /* LaunchViewController.swift in Sources */, + BFA8172B23C5633D001B5953 /* FetchAnisetteDataOperation.swift in Sources */, BFB1169B2293274D00BB457C /* JSONDecoder+ManagedObjectContext.swift in Sources */, BF9ABA4722DD0638008935CF /* BrowseCollectionViewCell.swift in Sources */, BF3D648822E79A3700E9056B /* AppPermission.swift in Sources */, @@ -1493,11 +1728,14 @@ BFF0B69A2322D7D0007A79E1 /* UIScreen+CompactHeight.swift in Sources */, BFD5D6EE230D8A86007955AB /* Patron.swift in Sources */, BF8F69C222E659F700049BA1 /* AppContentViewController.swift in Sources */, + BF7C627423DBB78C00515A2D /* InstalledAppPolicy.swift in Sources */, + BFA8172F23C5831A001B5953 /* PrepareDeveloperAccountOperation.swift in Sources */, BF08858522DE7EC800DE9F1E /* UpdateCollectionViewCell.swift in Sources */, BF258CE322EBAE2800023032 /* AppProtocol.swift in Sources */, BF770E5822BC3D0F002A40FE /* OperationGroup.swift in Sources */, BF18B0F122E25DF9005C4CF5 /* ToastView.swift in Sources */, BF3D649F22E7B24C00E9056B /* CollapsingTextView.swift in Sources */, + BF0F5FC723F394AD0080DB64 /* AltStore3ToAltStore4.xcmappingmodel in Sources */, BF02419622F2199300129732 /* RefreshAttemptsViewController.swift in Sources */, BF08858322DE795100DE9F1E /* MyAppsViewController.swift in Sources */, BF9ABA4F22DD41A9008935CF /* UIColor+Hex.swift in Sources */, @@ -1505,6 +1743,7 @@ BFD52BD422A0800A000B7ED1 /* ServerManager.swift in Sources */, BFDB6A0822AAED73007EA6D6 /* ResignAppOperation.swift in Sources */, BF3D64A222E8031100E9056B /* MergePolicy.swift in Sources */, + BF7C627223DBB3B400515A2D /* AltStore2ToAltStore3.xcmappingmodel in Sources */, BF770E5122BB1CF6002A40FE /* InstallAppOperation.swift in Sources */, BF9ABA4B22DD1380008935CF /* NavigationBar.swift in Sources */, BF0C4EBD22A1BD8B009A2DD7 /* AppManager.swift in Sources */, @@ -1522,6 +1761,8 @@ BFDB5B1622EE90D300F74113 /* Date+RelativeDate.swift in Sources */, BFF0B69023219C6D007A79E1 /* PatreonComponents.swift in Sources */, BF770E5622BC3C03002A40FE /* Server.swift in Sources */, + BFA8172923C56042001B5953 /* ServerConnection.swift in Sources */, + BF56D2AF23DF9E310006506D /* AppIDsViewController.swift in Sources */, BF43003022A71C960051E2BC /* UserDefaults+AltStore.swift in Sources */, ); runOnlyForDeploymentPostprocessing = 0; @@ -1544,6 +1785,11 @@ target = BF45872A2298D31600BD7491 /* libimobiledevice */; targetProxy = BF4588442298D48B00BD7491 /* PBXContainerItemProxy */; }; + BFBFFB272380C72F00993A4A /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = BF5C5FC4237DF5AE00EDD0C6 /* AltPlugin */; + targetProxy = BFBFFB262380C72F00993A4A /* PBXContainerItemProxy */; + }; /* End PBXTargetDependency section */ /* Begin PBXVariantGroup section */ @@ -1610,12 +1856,15 @@ }; BF45869B229872EA00BD7491 /* Debug */ = { isa = XCBuildConfiguration; + baseConfigurationReference = 11611D46F8A7C8B928E8156B /* Pods-AltServer.debug.xcconfig */; buildSettings = { ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; CLANG_ENABLE_MODULES = YES; + CODE_SIGN_ENTITLEMENTS = AltServer/AltServer.entitlements; CODE_SIGN_IDENTITY = "Mac Developer"; CODE_SIGN_STYLE = Automatic; COMBINE_HIDPI_IMAGES = YES; + CURRENT_PROJECT_VERSION = 8; DEVELOPMENT_TEAM = 6XVY5G3U44; ENABLE_HARDENED_RUNTIME = YES; FRAMEWORK_SEARCH_PATHS = ( @@ -1648,6 +1897,7 @@ "@executable_path/../Frameworks", ); MACOSX_DEPLOYMENT_TARGET = 10.14.4; + MARKETING_VERSION = 1.2; PRODUCT_BUNDLE_IDENTIFIER = com.rileytestut.AltServer; PRODUCT_NAME = "$(TARGET_NAME)"; SDKROOT = macosx; @@ -1659,12 +1909,15 @@ }; BF45869C229872EA00BD7491 /* Release */ = { isa = XCBuildConfiguration; + baseConfigurationReference = 589BA531D903B28F292063E5 /* Pods-AltServer.release.xcconfig */; buildSettings = { ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; CLANG_ENABLE_MODULES = YES; + CODE_SIGN_ENTITLEMENTS = AltServer/AltServer.entitlements; CODE_SIGN_IDENTITY = "Mac Developer"; CODE_SIGN_STYLE = Automatic; COMBINE_HIDPI_IMAGES = YES; + CURRENT_PROJECT_VERSION = 8; DEVELOPMENT_TEAM = 6XVY5G3U44; ENABLE_HARDENED_RUNTIME = YES; FRAMEWORK_SEARCH_PATHS = ( @@ -1697,6 +1950,7 @@ "@executable_path/../Frameworks", ); MACOSX_DEPLOYMENT_TARGET = 10.14.4; + MARKETING_VERSION = 1.2; PRODUCT_BUNDLE_IDENTIFIER = com.rileytestut.AltServer; PRODUCT_NAME = "$(TARGET_NAME)"; SDKROOT = macosx; @@ -1779,6 +2033,63 @@ }; name = Release; }; + BF5C5FC9237DF5AE00EDD0C6 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CLANG_ENABLE_MODULES = YES; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CODE_SIGN_IDENTITY = "-"; + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + DEVELOPMENT_TEAM = ""; + INFOPLIST_FILE = AltPlugin/Info.plist; + INSTALL_PATH = "$(HOME)/Library/Mail/Bundles/"; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path", + "@executable_path/Frameworks", + "@loader_path/Frameworks", + "/Users/Riley/Library/Developer/Xcode/DerivedData/AltStore-bhqnkrahfutztzeudtxhcxccgtlo/Build/Products/Debug", + ); + MACOSX_DEPLOYMENT_TARGET = 10.14; + PRODUCT_BUNDLE_IDENTIFIER = com.rileytestut.AltPlugin; + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = macosx; + SKIP_INSTALL = YES; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + SWIFT_VERSION = 5.0; + WRAPPER_EXTENSION = mailbundle; + }; + name = Debug; + }; + BF5C5FCA237DF5AE00EDD0C6 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CLANG_ENABLE_MODULES = YES; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CODE_SIGN_IDENTITY = "-"; + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + DEVELOPMENT_TEAM = ""; + INFOPLIST_FILE = AltPlugin/Info.plist; + INSTALL_PATH = "$(HOME)/Library/Mail/Bundles/"; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path", + "@executable_path/Frameworks", + "@loader_path/Frameworks", + "/Users/Riley/Library/Developer/Xcode/DerivedData/AltStore-bhqnkrahfutztzeudtxhcxccgtlo/Build/Products/Debug", + ); + MACOSX_DEPLOYMENT_TARGET = 10.14; + PRODUCT_BUNDLE_IDENTIFIER = com.rileytestut.AltPlugin; + PRODUCT_NAME = "$(TARGET_NAME)"; + SDKROOT = macosx; + SKIP_INSTALL = YES; + SWIFT_VERSION = 5.0; + WRAPPER_EXTENSION = mailbundle; + }; + name = Release; + }; BFD2477C2284B9A700981D42 /* Debug */ = { isa = XCBuildConfiguration; buildSettings = { @@ -1913,6 +2224,7 @@ "$(inherited)", "@executable_path/Frameworks", ); + MARKETING_VERSION = 1.2; PRODUCT_BUNDLE_IDENTIFIER = com.rileytestut.AltStore; PRODUCT_NAME = "$(TARGET_NAME)"; PROVISIONING_PROFILE_SPECIFIER = ""; @@ -1939,6 +2251,7 @@ "$(inherited)", "@executable_path/Frameworks", ); + MARKETING_VERSION = 1.2; PRODUCT_BUNDLE_IDENTIFIER = com.rileytestut.AltStore; PRODUCT_NAME = "$(TARGET_NAME)"; PROVISIONING_PROFILE_SPECIFIER = ""; @@ -1978,6 +2291,15 @@ defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; }; + BF5C5FC8237DF5AE00EDD0C6 /* Build configuration list for PBXNativeTarget "AltPlugin" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + BF5C5FC9237DF5AE00EDD0C6 /* Debug */, + BF5C5FCA237DF5AE00EDD0C6 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; BFD247652284B9A500981D42 /* Build configuration list for PBXProject "AltStore" */ = { isa = XCConfigurationList; buildConfigurations = ( @@ -2002,10 +2324,12 @@ BFBBE2DB22931B20002097FA /* AltStore.xcdatamodeld */ = { isa = XCVersionGroup; children = ( + BF56D2A823DF87570006506D /* AltStore 4.xcdatamodel */, + BF7C627023DBB33300515A2D /* AltStore 3.xcdatamodel */, BF100C46232D7828006A8926 /* AltStore 2.xcdatamodel */, BFBBE2DC22931B20002097FA /* AltStore.xcdatamodel */, ); - currentVersion = BF100C46232D7828006A8926 /* AltStore 2.xcdatamodel */; + currentVersion = BF56D2A823DF87570006506D /* AltStore 4.xcdatamodel */; path = AltStore.xcdatamodeld; sourceTree = ""; versionGroupType = wrapper.xcdatamodel; diff --git a/AltStore.xcodeproj/xcshareddata/xcschemes/AltKit.xcscheme b/AltStore.xcodeproj/xcshareddata/xcschemes/AltKit.xcscheme new file mode 100644 index 00000000..9aa668c0 --- /dev/null +++ b/AltStore.xcodeproj/xcshareddata/xcschemes/AltKit.xcscheme @@ -0,0 +1,67 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/AltStore.xcodeproj/xcshareddata/xcschemes/AltPlugin.xcscheme b/AltStore.xcodeproj/xcshareddata/xcschemes/AltPlugin.xcscheme new file mode 100644 index 00000000..2bfc3556 --- /dev/null +++ b/AltStore.xcodeproj/xcshareddata/xcschemes/AltPlugin.xcscheme @@ -0,0 +1,67 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/AltStore/AltStore-Bridging-Header.h b/AltStore/AltStore-Bridging-Header.h index 89f935ce..3f1cb414 100644 --- a/AltStore/AltStore-Bridging-Header.h +++ b/AltStore/AltStore-Bridging-Header.h @@ -2,6 +2,8 @@ // Use this file to import your target's public headers that you would like to expose to Swift. // -#import "NSError+ALTServerError.h" +#import "AltKit.h" + #import "ALTAppPermission.h" #import "ALTPatreonBenefitType.h" +#import "ALTSourceUserInfoKey.h" diff --git a/AltStore/App Detail/AppContentViewController.swift b/AltStore/App Detail/AppContentViewController.swift index 33ddd9d5..fcdb9bfd 100644 --- a/AltStore/App Detail/AppContentViewController.swift +++ b/AltStore/App Detail/AppContentViewController.swift @@ -73,6 +73,8 @@ class AppContentViewController: UITableViewController self.tableView.contentInset.bottom = 20 self.screenshotsCollectionView.dataSource = self.screenshotsDataSource + self.screenshotsCollectionView.prefetchDataSource = self.screenshotsDataSource + self.permissionsCollectionView.dataSource = self.permissionsDataSource self.subtitleLabel.text = self.app.subtitle diff --git a/AltStore/App Detail/AppViewController.swift b/AltStore/App Detail/AppViewController.swift index d2b4ff5c..c9c04f99 100644 --- a/AltStore/App Detail/AppViewController.swift +++ b/AltStore/App Detail/AppViewController.swift @@ -27,18 +27,11 @@ class AppViewController: UIViewController @IBOutlet private var scrollView: UIScrollView! @IBOutlet private var contentView: UIView! - @IBOutlet private var headerView: UIView! - @IBOutlet private var headerContentView: UIView! + @IBOutlet private var bannerView: AppBannerView! @IBOutlet private var backButton: UIButton! @IBOutlet private var backButtonContainerView: UIVisualEffectView! - @IBOutlet private var nameLabel: UILabel! - @IBOutlet private var developerLabel: UILabel! - @IBOutlet private var downloadButton: PillButton! - @IBOutlet private var appIconImageView: UIImageView! - @IBOutlet private var betaBadgeView: UIImageView! - @IBOutlet private var backgroundAppIconImageView: UIImageView! @IBOutlet private var backgroundBlurView: UIVisualEffectView! @@ -51,6 +44,12 @@ class AppViewController: UIViewController private var _backgroundBlurEffect: UIBlurEffect? private var _backgroundBlurTintColor: UIColor? + private var _preferredStatusBarStyle: UIStatusBarStyle = .default + + override var preferredStatusBarStyle: UIStatusBarStyle { + return _preferredStatusBarStyle + } + override func viewDidLoad() { super.viewDidLoad() @@ -75,21 +74,22 @@ class AppViewController: UIViewController self.contentViewController.tableView.panGestureRecognizer.require(toFail: self.scrollView.panGestureRecognizer) self.contentViewController.tableView.showsVerticalScrollIndicator = false - self.headerView.frame = CGRect(x: 0, y: 0, width: 300, height: 93) - self.headerView.layer.cornerRadius = 24 - self.headerView.layer.masksToBounds = true - // Bring to front so the scroll indicators are visible. self.view.bringSubviewToFront(self.scrollView) self.scrollView.isUserInteractionEnabled = false - self.nameLabel.text = self.app.name - self.developerLabel.text = self.app.developerName - self.developerLabel.textColor = self.app.tintColor - self.appIconImageView.image = nil - self.appIconImageView.tintColor = self.app.tintColor - self.downloadButton.tintColor = self.app.tintColor - self.betaBadgeView.isHidden = !self.app.isBeta + self.bannerView.frame = CGRect(x: 0, y: 0, width: 300, height: 93) + self.bannerView.backgroundEffectView.effect = UIBlurEffect(style: .regular) + self.bannerView.backgroundEffectView.backgroundColor = .clear + self.bannerView.titleLabel.text = self.app.name + self.bannerView.subtitleLabel.text = self.app.developerName + self.bannerView.iconImageView.image = nil + self.bannerView.iconImageView.tintColor = self.app.tintColor + self.bannerView.button.tintColor = self.app.tintColor + self.bannerView.betaBadgeView.isHidden = !self.app.isBeta + self.bannerView.tintColor = self.app.tintColor + + self.bannerView.button.addTarget(self, action: #selector(AppViewController.performAppAction(_:)), for: .primaryActionTriggered) self.backButtonContainerView.tintColor = self.app.tintColor @@ -107,12 +107,13 @@ class AppViewController: UIViewController NotificationCenter.default.addObserver(self, selector: #selector(AppViewController.didChangeApp(_:)), name: .NSManagedObjectContextObjectsDidChange, object: DatabaseManager.shared.viewContext) NotificationCenter.default.addObserver(self, selector: #selector(AppViewController.willEnterForeground(_:)), name: UIApplication.willEnterForegroundNotification, object: nil) + NotificationCenter.default.addObserver(self, selector: #selector(AppViewController.didBecomeActive(_:)), name: UIApplication.didBecomeActiveNotification, object: nil) self._backgroundBlurEffect = self.backgroundBlurView.effect as? UIBlurEffect self._backgroundBlurTintColor = self.backgroundBlurView.contentView.backgroundColor // Load Images - for imageView in [self.appIconImageView!, self.backgroundAppIconImageView!, self.navigationBarAppIconImageView!] + for imageView in [self.bannerView.iconImageView!, self.backgroundAppIconImageView!, self.navigationBarAppIconImageView!] { imageView.isIndicatingActivity = true @@ -219,7 +220,7 @@ class AppViewController: UIViewController var backButtonFrame = CGRect(x: inset, y: statusBarHeight, width: backButtonSize.width + 20, height: backButtonSize.height + 20) - var headerFrame = CGRect(x: inset, y: 0, width: self.view.bounds.width - inset * 2, height: self.headerView.bounds.height) + var headerFrame = CGRect(x: inset, y: 0, width: self.view.bounds.width - inset * 2, height: self.bannerView.bounds.height) var contentFrame = CGRect(x: 0, y: 0, width: self.view.bounds.width, height: self.view.bounds.height) var backgroundIconFrame = CGRect(x: 0, y: 0, width: self.view.bounds.width, height: self.view.bounds.width) @@ -305,12 +306,11 @@ class AppViewController: UIViewController // Set frames. self.contentViewController.view.superview?.frame = contentFrame - self.headerView.frame = headerFrame + self.bannerView.frame = headerFrame self.backgroundAppIconImageView.frame = backgroundIconFrame self.backgroundBlurView.frame = backgroundIconFrame self.backButtonContainerView.frame = backButtonFrame - self.headerContentView.frame = CGRect(x: 0, y: 0, width: self.headerView.bounds.width, height: self.headerView.bounds.height) self.contentViewControllerShadowView.frame = self.contentViewController.view.frame self.backButtonContainerView.layer.cornerRadius = self.backButtonContainerView.bounds.midY @@ -325,6 +325,14 @@ class AppViewController: UIViewController self.scrollView.contentSize = contentSize self.scrollView.contentOffset = contentOffset + + self.bannerView.backgroundEffectView.backgroundColor = .clear + } + + override func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) + { + super.traitCollectionDidChange(previousTraitCollection) + self._shouldResetLayout = true } deinit @@ -350,7 +358,7 @@ private extension AppViewController { func update() { - for button in [self.downloadButton!, self.navigationBarDownloadButton!] + for button in [self.bannerView.button!, self.navigationBarDownloadButton!] { button.tintColor = self.app.tintColor button.isIndicatingActivity = false @@ -358,12 +366,10 @@ private extension AppViewController if self.app.installedApp == nil { button.setTitle(NSLocalizedString("FREE", comment: ""), for: .normal) - button.isInverted = false } else { button.setTitle(NSLocalizedString("OPEN", comment: ""), for: .normal) - button.isInverted = true } let progress = AppManager.shared.installationProgress(for: self.app) @@ -372,12 +378,12 @@ private extension AppViewController if Date() < self.app.versionDate { - self.downloadButton.countdownDate = self.app.versionDate + self.bannerView.button.countdownDate = self.app.versionDate self.navigationBarDownloadButton.countdownDate = self.app.versionDate } else { - self.downloadButton.countdownDate = nil + self.bannerView.button.countdownDate = nil self.navigationBarDownloadButton.countdownDate = nil } @@ -389,18 +395,29 @@ private extension AppViewController func showNavigationBar(for navigationController: UINavigationController? = nil) { let navigationController = navigationController ?? self.navigationController - navigationController?.navigationBar.barStyle = .default navigationController?.navigationBar.alpha = 1.0 - navigationController?.navigationBar.barTintColor = .white navigationController?.navigationBar.tintColor = .altPrimary + navigationController?.navigationBar.setNeedsLayout() + + if self.traitCollection.userInterfaceStyle == .dark + { + self._preferredStatusBarStyle = .lightContent + } + else + { + self._preferredStatusBarStyle = .default + } + + navigationController?.setNeedsStatusBarAppearanceUpdate() } func hideNavigationBar(for navigationController: UINavigationController? = nil) { let navigationController = navigationController ?? self.navigationController - navigationController?.navigationBar.barStyle = .black navigationController?.navigationBar.alpha = 0.0 - navigationController?.navigationBar.barTintColor = .white + + self._preferredStatusBarStyle = .lightContent + navigationController?.setNeedsStatusBarAppearanceUpdate() } func prepareBlur() @@ -445,7 +462,7 @@ private extension AppViewController self.navigationBarAnimator = nil self.hideNavigationBar() - self.navigationController?.navigationBar.barTintColor = .white + self.contentViewController.view.layer.cornerRadius = self.contentViewControllerShadowView.layer.cornerRadius } } @@ -485,18 +502,20 @@ extension AppViewController catch { DispatchQueue.main.async { - let toastView = ToastView(text: error.localizedDescription, detailText: nil) - toastView.show(in: self.navigationController?.view ?? self.view, duration: 2) + let toastView = ToastView(error: error) + toastView.show(in: self) } } DispatchQueue.main.async { - self.downloadButton.progress = nil + self.bannerView.button.progress = nil + self.navigationBarDownloadButton.progress = nil self.update() } } - self.downloadButton.progress = progress + self.bannerView.button.progress = progress + self.navigationBarDownloadButton.progress = progress } func open(_ installedApp: InstalledApp) @@ -522,6 +541,15 @@ private extension AppViewController self._shouldResetLayout = true self.view.setNeedsLayout() } + + @objc func didBecomeActive(_ notification: Notification) + { + guard let navigationController = self.navigationController, navigationController.topViewController == self else { return } + + // Fixes Navigation Bar appearing after app becomes inactive -> active again. + self._shouldResetLayout = true + self.view.setNeedsLayout() + } } extension AppViewController: UIScrollViewDelegate diff --git a/AltStore/App IDs/AppIDComponents.swift b/AltStore/App IDs/AppIDComponents.swift new file mode 100644 index 00000000..abbfca0d --- /dev/null +++ b/AltStore/App IDs/AppIDComponents.swift @@ -0,0 +1,30 @@ +// +// AppIDComponents.swift +// AltStore +// +// Created by Riley Testut on 2/10/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +import UIKit + +class AppIDCollectionViewCell: UICollectionViewCell +{ + @IBOutlet var bannerView: AppBannerView! + + override func awakeFromNib() + { + super.awakeFromNib() + + self.contentView.autoresizingMask = [.flexibleWidth, .flexibleHeight] + self.contentView.preservesSuperviewLayoutMargins = true + + self.bannerView.buttonLabel.text = NSLocalizedString("Expires in", comment: "") + self.bannerView.buttonLabel.isHidden = false + } +} + +class AppIDsCollectionReusableView: UICollectionReusableView +{ + @IBOutlet var textLabel: UILabel! +} diff --git a/AltStore/App IDs/AppIDsViewController.swift b/AltStore/App IDs/AppIDsViewController.swift new file mode 100644 index 00000000..b029e0d2 --- /dev/null +++ b/AltStore/App IDs/AppIDsViewController.swift @@ -0,0 +1,225 @@ +// +// AppIDsViewController.swift +// AltStore +// +// Created by Riley Testut on 1/27/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +import UIKit + +import Roxas + +class AppIDsViewController: UICollectionViewController +{ + private lazy var dataSource = self.makeDataSource() + + private var didInitialFetch = false + private var isLoading = false { + didSet { + self.update() + } + } + + @IBOutlet var activityIndicatorBarButtonItem: UIBarButtonItem! + + override func viewDidLoad() + { + super.viewDidLoad() + + self.collectionView.dataSource = self.dataSource + + self.activityIndicatorBarButtonItem.isIndicatingActivity = true + + let refreshControl = UIRefreshControl() + refreshControl.addTarget(self, action: #selector(AppIDsViewController.fetchAppIDs), for: .primaryActionTriggered) + self.collectionView.refreshControl = refreshControl + } + + override func viewWillAppear(_ animated: Bool) + { + super.viewWillAppear(animated) + + if !self.didInitialFetch + { + self.fetchAppIDs() + } + } +} + +private extension AppIDsViewController +{ + func makeDataSource() -> RSTFetchedResultsCollectionViewDataSource + { + let fetchRequest = AppID.fetchRequest() as NSFetchRequest + fetchRequest.sortDescriptors = [NSSortDescriptor(keyPath: \AppID.name, ascending: true), + NSSortDescriptor(keyPath: \AppID.bundleIdentifier, ascending: true), + NSSortDescriptor(keyPath: \AppID.expirationDate, ascending: true)] + fetchRequest.returnsObjectsAsFaults = false + + if let team = DatabaseManager.shared.activeTeam() + { + fetchRequest.predicate = NSPredicate(format: "%K == %@", #keyPath(AppID.team), team) + } + else + { + fetchRequest.predicate = NSPredicate(value: false) + } + + let dataSource = RSTFetchedResultsCollectionViewDataSource(fetchRequest: fetchRequest, managedObjectContext: DatabaseManager.shared.viewContext) + dataSource.proxy = self + dataSource.cellConfigurationHandler = { (cell, appID, indexPath) in + let tintColor = UIColor.altPrimary + + let cell = cell as! AppIDCollectionViewCell + cell.layoutMargins.left = self.view.layoutMargins.left + cell.layoutMargins.right = self.view.layoutMargins.right + cell.tintColor = tintColor + + cell.bannerView.iconImageView.isHidden = true + cell.bannerView.button.isIndicatingActivity = false + cell.bannerView.betaBadgeView.isHidden = true + + if let expirationDate = appID.expirationDate + { + cell.bannerView.button.isHidden = false + cell.bannerView.button.isUserInteractionEnabled = false + + cell.bannerView.buttonLabel.isHidden = false + + let currentDate = Date() + + let numberOfDays = expirationDate.numberOfCalendarDays(since: currentDate) + + if numberOfDays == 1 + { + cell.bannerView.button.setTitle(NSLocalizedString("1 DAY", comment: ""), for: .normal) + } + else + { + cell.bannerView.button.setTitle(String(format: NSLocalizedString("%@ DAYS", comment: ""), NSNumber(value: numberOfDays)), for: .normal) + } + } + else + { + cell.bannerView.button.isHidden = true + cell.bannerView.buttonLabel.isHidden = true + } + + cell.bannerView.titleLabel.text = appID.name + cell.bannerView.subtitleLabel.text = appID.bundleIdentifier + cell.bannerView.subtitleLabel.numberOfLines = 2 + + // Make sure refresh button is correct size. + cell.layoutIfNeeded() + } + + return dataSource + } + + @objc func fetchAppIDs() + { + guard !self.isLoading else { return } + self.isLoading = true + + AppManager.shared.fetchAppIDs { (result) in + do + { + let (_, context) = try result.get() + try context.save() + } + catch + { + DispatchQueue.main.async { + let toastView = ToastView(error: error) + toastView.show(in: self) + } + } + + DispatchQueue.main.async { + self.isLoading = false + } + } + } + + func update() + { + if !self.isLoading + { + self.collectionView.refreshControl?.endRefreshing() + self.activityIndicatorBarButtonItem.isIndicatingActivity = false + } + } +} + +extension AppIDsViewController: UICollectionViewDelegateFlowLayout +{ + func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAt indexPath: IndexPath) -> CGSize + { + return CGSize(width: collectionView.bounds.width, height: 80) + } + + func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, referenceSizeForHeaderInSection section: Int) -> CGSize + { + let indexPath = IndexPath(row: 0, section: section) + let headerView = self.collectionView(collectionView, viewForSupplementaryElementOfKind: UICollectionView.elementKindSectionHeader, at: indexPath) + + // Use this view to calculate the optimal size based on the collection view's width + let size = headerView.systemLayoutSizeFitting(CGSize(width: collectionView.frame.width, height: UIView.layoutFittingExpandedSize.height), + withHorizontalFittingPriority: .required, // Width is fixed + verticalFittingPriority: .fittingSizeLevel) // Height can be as large as needed + return size + } + + func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, referenceSizeForFooterInSection section: Int) -> CGSize + { + return CGSize(width: collectionView.bounds.width, height: 50) + } + + override func collectionView(_ collectionView: UICollectionView, viewForSupplementaryElementOfKind kind: String, at indexPath: IndexPath) -> UICollectionReusableView + { + switch kind + { + case UICollectionView.elementKindSectionHeader: + let headerView = collectionView.dequeueReusableSupplementaryView(ofKind: kind, withReuseIdentifier: "Header", for: indexPath) as! AppIDsCollectionReusableView + headerView.layoutMargins.left = self.view.layoutMargins.left + headerView.layoutMargins.right = self.view.layoutMargins.right + + if let activeTeam = DatabaseManager.shared.activeTeam(), activeTeam.type == .free + { + headerView.textLabel.text = """ + Each app and app extension installed with AltStore must register an App ID with Apple. Apple limits free developer accounts to 10 App IDs at a time. + + App IDs expire after one week, but AltStore will automatically renew them for all installed apps. Once an App ID expires, it no longer counts toward your total. + """ + } + else + { + headerView.textLabel.text = """ + Each app and app extension installed with AltStore must register an App ID with Apple. + + App IDs for paid developer accounts never expire, and there is no limit to how many you can create. + """ + } + + return headerView + + case UICollectionView.elementKindSectionFooter: + let footerView = collectionView.dequeueReusableSupplementaryView(ofKind: kind, withReuseIdentifier: "Footer", for: indexPath) as! AppIDsCollectionReusableView + + let count = self.dataSource.itemCount + if count == 1 + { + footerView.textLabel.text = NSLocalizedString("1 App ID", comment: "") + } + else + { + footerView.textLabel.text = String(format: NSLocalizedString("%@ App IDs", comment: ""), NSNumber(value: count)) + } + + return footerView + + default: fatalError() + } + } +} diff --git a/AltStore/Authentication/Authentication.storyboard b/AltStore/Authentication/Authentication.storyboard index 50d473c7..685a725e 100644 --- a/AltStore/Authentication/Authentication.storyboard +++ b/AltStore/Authentication/Authentication.storyboard @@ -1,9 +1,9 @@ - + - + @@ -17,7 +17,7 @@ - + @@ -51,7 +51,7 @@ - + @@ -65,16 +65,16 @@ - + - + @@ -118,7 +118,7 @@ - + @@ -156,31 +156,19 @@ - - - - - - - - + @@ -443,14 +431,78 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + + + diff --git a/AltStore/Authentication/AuthenticationViewController.swift b/AltStore/Authentication/AuthenticationViewController.swift index 56aefd43..9268964a 100644 --- a/AltStore/Authentication/AuthenticationViewController.swift +++ b/AltStore/Authentication/AuthenticationViewController.swift @@ -12,7 +12,8 @@ import AltSign class AuthenticationViewController: UIViewController { - var authenticationHandler: (((ALTAccount, String)?) -> Void)? + var authenticationHandler: ((String, String, @escaping (Result<(ALTAccount, ALTAppleAPISession), Error>) -> Void) -> Void)? + var completionHandler: (((ALTAccount, ALTAppleAPISession, String)?) -> Void)? private weak var toastView: ToastView? @@ -30,6 +31,8 @@ class AuthenticationViewController: UIViewController { super.viewDidLoad() + self.signInButton.activityIndicatorView.style = .white + for view in [self.appleIDBackgroundView!, self.passwordBackgroundView!, self.signInButton!] { view.clipsToBounds = true @@ -94,14 +97,16 @@ private extension AuthenticationViewController self.signInButton.isIndicatingActivity = true - ALTAppleAPI.shared.authenticate(appleID: emailAddress, password: password) { (account, error) in - do - { - let account = try Result(account, error).get() - self.authenticationHandler?((account, password)) - } - catch + self.authenticationHandler?(emailAddress, password) { (result) in + switch result { + case .failure(ALTAppleAPIError.requiresTwoFactorAuthentication): + // Ignore + DispatchQueue.main.async { + self.signInButton.isIndicatingActivity = false + } + + case .failure(let error): DispatchQueue.main.async { let toastView = ToastView(text: NSLocalizedString("Failed to Log In", comment: ""), detailText: error.localizedDescription) toastView.textLabel.textColor = .altPink @@ -111,6 +116,9 @@ private extension AuthenticationViewController self.signInButton.isIndicatingActivity = false } + + case .success(let account, let session): + self.completionHandler?((account, session, password)) } DispatchQueue.main.async { @@ -121,7 +129,7 @@ private extension AuthenticationViewController @IBAction func cancel(_ sender: UIBarButtonItem) { - self.authenticationHandler?(nil) + self.completionHandler?(nil) } } diff --git a/AltStore/Authentication/InstructionsViewController.swift b/AltStore/Authentication/InstructionsViewController.swift index 744da7af..0a37f2be 100644 --- a/AltStore/Authentication/InstructionsViewController.swift +++ b/AltStore/Authentication/InstructionsViewController.swift @@ -17,6 +17,10 @@ class InstructionsViewController: UIViewController @IBOutlet private var contentStackView: UIStackView! @IBOutlet private var dismissButton: UIButton! + override var preferredStatusBarStyle: UIStatusBarStyle { + return .lightContent + } + override func viewDidLoad() { super.viewDidLoad() diff --git a/AltStore/Authentication/RefreshAltStoreViewController.swift b/AltStore/Authentication/RefreshAltStoreViewController.swift new file mode 100644 index 00000000..74c33570 --- /dev/null +++ b/AltStore/Authentication/RefreshAltStoreViewController.swift @@ -0,0 +1,89 @@ +// +// RefreshAltStoreViewController.swift +// AltStore +// +// Created by Riley Testut on 10/26/19. +// Copyright © 2019 Riley Testut. All rights reserved. +// + +import UIKit +import AltSign + +import Roxas + +class RefreshAltStoreViewController: UIViewController +{ + var signer: ALTSigner! + var session: ALTAppleAPISession! + + var completionHandler: ((Result) -> Void)? + + @IBOutlet private var placeholderView: RSTPlaceholderView! + + override func viewDidLoad() + { + super.viewDidLoad() + + self.placeholderView.textLabel.isHidden = true + + self.placeholderView.detailTextLabel.textAlignment = .left + self.placeholderView.detailTextLabel.textColor = UIColor.white.withAlphaComponent(0.6) + self.placeholderView.detailTextLabel.text = NSLocalizedString("AltStore was unable to use an existing signing certificate, so it had to create a new one. This will cause any apps installed with an existing certificate to expire — including AltStore.\n\nTo prevent AltStore from expiring early, please refresh the app now. AltStore will quit once refreshing is complete.", comment: "") + } +} + +private extension RefreshAltStoreViewController +{ + @IBAction func refreshAltStore(_ sender: PillButton) + { + guard let altStore = InstalledApp.fetchAltStore(in: DatabaseManager.shared.viewContext) else { return } + + func refresh() + { + sender.isIndicatingActivity = true + + if let progress = AppManager.shared.refreshProgress(for: altStore) ?? AppManager.shared.installationProgress(for: altStore) + { + // Cancel pending AltStore refresh so we can start a new one. + progress.cancel() + } + + let group = OperationGroup() + group.signer = self.signer // Prevent us from trying to authenticate a second time. + group.session = self.session // ^ + group.completionHandler = { (result) in + if let error = result.error ?? result.value?.values.compactMap({ $0.error }).first + { + DispatchQueue.main.async { + sender.progress = nil + sender.isIndicatingActivity = false + + let alertController = UIAlertController(title: NSLocalizedString("Failed to Refresh AltStore", comment: ""), message: error.localizedDescription, preferredStyle: .alert) + alertController.addAction(UIAlertAction(title: NSLocalizedString("Try Again", comment: ""), style: .default, handler: { (action) in + refresh() + })) + alertController.addAction(UIAlertAction(title: NSLocalizedString("Refresh Later", comment: ""), style: .cancel, handler: { (action) in + self.completionHandler?(.failure(error)) + })) + + self.present(alertController, animated: true, completion: nil) + } + } + else + { + self.completionHandler?(.success(())) + } + } + + _ = AppManager.shared.refresh([altStore], presentingViewController: self, group: group) + sender.progress = group.progress + } + + refresh() + } + + @IBAction func cancel(_ sender: UIButton) + { + self.completionHandler?(.failure(OperationError.cancelled)) + } +} diff --git a/AltStore/Base.lproj/LaunchScreen.storyboard b/AltStore/Base.lproj/LaunchScreen.storyboard index bfa36129..3e3d3444 100644 --- a/AltStore/Base.lproj/LaunchScreen.storyboard +++ b/AltStore/Base.lproj/LaunchScreen.storyboard @@ -1,7 +1,10 @@ - - + + + - + + + @@ -11,15 +14,38 @@ - + - + + - + + + + + + + + + + + + + + + + + + + + + + + diff --git a/AltStore/Base.lproj/Main.storyboard b/AltStore/Base.lproj/Main.storyboard index 3fb0ebd8..99fa18d2 100644 --- a/AltStore/Base.lproj/Main.storyboard +++ b/AltStore/Base.lproj/Main.storyboard @@ -1,12 +1,11 @@ - + - + - @@ -20,9 +19,6 @@ - - - @@ -31,7 +27,7 @@ - + @@ -55,12 +51,12 @@ - - + + - + @@ -110,10 +106,9 @@ - - + @@ -124,69 +119,10 @@ - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + @@ -201,22 +137,35 @@ - + + + + + + + + + + + - + - + @@ -248,18 +197,12 @@ - - + - - - - - @@ -278,7 +221,7 @@ - + @@ -303,6 +246,7 @@ + @@ -314,7 +258,7 @@ - + @@ -340,6 +284,7 @@ + @@ -351,7 +296,7 @@ - + @@ -363,6 +308,7 @@ + @@ -416,7 +362,7 @@ - + @@ -431,6 +377,7 @@ + @@ -451,7 +398,7 @@ - + @@ -521,6 +468,7 @@ World + @@ -575,7 +523,7 @@ World - + @@ -610,12 +558,12 @@ World - + - + - + @@ -632,7 +580,7 @@ World - + @@ -652,7 +600,7 @@ World - + @@ -677,112 +625,102 @@ World - + - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + - - - - - + + + + - - - - - + - + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + + + + + + @@ -812,6 +750,40 @@ World + + + + + + + + + + + + + + + + + + + + + + @@ -830,12 +802,120 @@ World - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -852,20 +932,43 @@ World + + + + + + + + + + + + + + + + + + - + + + + + + - + diff --git a/AltStore/Browse/BrowseCollectionViewCell.swift b/AltStore/Browse/BrowseCollectionViewCell.swift index 3192c28f..e27b51bf 100644 --- a/AltStore/Browse/BrowseCollectionViewCell.swift +++ b/AltStore/Browse/BrowseCollectionViewCell.swift @@ -20,40 +20,24 @@ import Nuke } } private lazy var dataSource = self.makeDataSource() - - @IBOutlet var nameLabel: UILabel! - @IBOutlet var developerLabel: UILabel! - @IBOutlet var appIconImageView: UIImageView! - @IBOutlet var actionButton: PillButton! + + @IBOutlet var bannerView: AppBannerView! @IBOutlet var subtitleLabel: UILabel! - @IBOutlet var screenshotsCollectionView: UICollectionView! - @IBOutlet var betaBadgeView: UIImageView! - - @IBOutlet private var screenshotsContentView: UIView! + @IBOutlet private(set) var screenshotsCollectionView: UICollectionView! override func awakeFromNib() { super.awakeFromNib() + self.contentView.preservesSuperviewLayoutMargins = true + // Must be registered programmatically, not in BrowseCollectionViewCell.xib, or else it'll throw an exception 🤷‍♂️. self.screenshotsCollectionView.register(ScreenshotCollectionViewCell.self, forCellWithReuseIdentifier: RSTCellContentGenericCellIdentifier) self.screenshotsCollectionView.delegate = self self.screenshotsCollectionView.dataSource = self.dataSource self.screenshotsCollectionView.prefetchDataSource = self.dataSource - - self.screenshotsContentView.layer.cornerRadius = 20 - self.screenshotsContentView.layer.masksToBounds = true - - self.update() - } - - override func tintColorDidChange() - { - super.tintColorDidChange() - - self.update() } } @@ -96,12 +80,6 @@ private extension BrowseCollectionViewCell return dataSource } - - private func update() - { - self.subtitleLabel.textColor = self.tintColor - self.screenshotsContentView.backgroundColor = self.tintColor.withAlphaComponent(0.1) - } } extension BrowseCollectionViewCell: UICollectionViewDelegateFlowLayout diff --git a/AltStore/Browse/BrowseCollectionViewCell.xib b/AltStore/Browse/BrowseCollectionViewCell.xib index 41e216af..ecd02b4e 100644 --- a/AltStore/Browse/BrowseCollectionViewCell.xib +++ b/AltStore/Browse/BrowseCollectionViewCell.xib @@ -1,131 +1,64 @@ - - - - + + - - + - - + + - + - - + + - - + + + - - + - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + - - - - - - + - + - - - diff --git a/AltStore/Browse/BrowseViewController.swift b/AltStore/Browse/BrowseViewController.swift index b08f4d69..b9637497 100644 --- a/AltStore/Browse/BrowseViewController.swift +++ b/AltStore/Browse/BrowseViewController.swift @@ -72,47 +72,49 @@ private extension BrowseViewController let dataSource = RSTFetchedResultsCollectionViewPrefetchingDataSource(fetchRequest: fetchRequest, managedObjectContext: DatabaseManager.shared.viewContext) dataSource.cellConfigurationHandler = { (cell, app, indexPath) in let cell = cell as! BrowseCollectionViewCell - cell.nameLabel.text = app.name - cell.developerLabel.text = app.developerName + cell.layoutMargins.left = self.view.layoutMargins.left + cell.layoutMargins.right = self.view.layoutMargins.right + cell.subtitleLabel.text = app.subtitle cell.imageURLs = Array(app.screenshotURLs.prefix(2)) - cell.appIconImageView.image = nil - cell.appIconImageView.isIndicatingActivity = true - cell.betaBadgeView.isHidden = !app.isBeta + cell.bannerView.titleLabel.text = app.name + cell.bannerView.subtitleLabel.text = app.developerName + cell.bannerView.betaBadgeView.isHidden = !app.isBeta - cell.actionButton.addTarget(self, action: #selector(BrowseViewController.performAppAction(_:)), for: .primaryActionTriggered) - cell.actionButton.activityIndicatorView.style = .white + cell.bannerView.iconImageView.image = nil + cell.bannerView.iconImageView.isIndicatingActivity = true + + cell.bannerView.button.addTarget(self, action: #selector(BrowseViewController.performAppAction(_:)), for: .primaryActionTriggered) + cell.bannerView.button.activityIndicatorView.style = .white // Explicitly set to false to ensure we're starting from a non-activity indicating state. // Otherwise, cell reuse can mess up some cached values. - cell.actionButton.isIndicatingActivity = false + cell.bannerView.button.isIndicatingActivity = false let tintColor = app.tintColor ?? .altPrimary cell.tintColor = tintColor if app.installedApp == nil { - cell.actionButton.setTitle(NSLocalizedString("FREE", comment: ""), for: .normal) + cell.bannerView.button.setTitle(NSLocalizedString("FREE", comment: ""), for: .normal) let progress = AppManager.shared.installationProgress(for: app) - cell.actionButton.progress = progress - cell.actionButton.isInverted = false + cell.bannerView.button.progress = progress if Date() < app.versionDate { - cell.actionButton.countdownDate = app.versionDate + cell.bannerView.button.countdownDate = app.versionDate } else { - cell.actionButton.countdownDate = nil + cell.bannerView.button.countdownDate = nil } } else { - cell.actionButton.setTitle(NSLocalizedString("OPEN", comment: ""), for: .normal) - cell.actionButton.progress = nil - cell.actionButton.isInverted = true - cell.actionButton.countdownDate = nil + cell.bannerView.button.setTitle(NSLocalizedString("OPEN", comment: ""), for: .normal) + cell.bannerView.button.progress = nil + cell.bannerView.button.countdownDate = nil } } dataSource.prefetchHandler = { (storeApp, indexPath, completionHandler) -> Foundation.Operation? in @@ -135,8 +137,8 @@ private extension BrowseViewController } dataSource.prefetchCompletionHandler = { (cell, image, indexPath, error) in let cell = cell as! BrowseCollectionViewCell - cell.appIconImageView.isIndicatingActivity = false - cell.appIconImageView.image = image + cell.bannerView.iconImageView.isIndicatingActivity = false + cell.bannerView.iconImageView.image = image if let error = error { @@ -253,8 +255,8 @@ private extension BrowseViewController { case .failure(OperationError.cancelled): break // Ignore case .failure(let error): - let toastView = ToastView(text: error.localizedDescription, detailText: nil) - toastView.show(in: self.navigationController?.view ?? self.view, duration: 2) + let toastView = ToastView(error: error) + toastView.show(in: self) case .success: print("Installed app:", app.bundleIdentifier) } @@ -286,8 +288,8 @@ extension BrowseViewController: UICollectionViewDelegateFlowLayout let maxVisibleScreenshots = 2 as CGFloat let aspectRatio: CGFloat = 16.0 / 9.0 - let layout = collectionViewLayout as! UICollectionViewFlowLayout - let padding = (layout.minimumInteritemSpacing * (maxVisibleScreenshots - 1)) + let layout = self.prototypeCell.screenshotsCollectionView.collectionViewLayout as! UICollectionViewFlowLayout + let padding = (layout.minimumInteritemSpacing * (maxVisibleScreenshots - 1)) + layout.sectionInset.left + layout.sectionInset.right self.dataSource.cellConfigurationHandler(self.prototypeCell, item, indexPath) @@ -295,6 +297,8 @@ extension BrowseViewController: UICollectionViewDelegateFlowLayout widthConstraint.isActive = true defer { widthConstraint.isActive = false } + // Manually update cell width & layout so we can accurately calculate screenshot sizes. + self.prototypeCell.frame.size.width = widthConstraint.constant self.prototypeCell.layoutIfNeeded() let collectionViewWidth = self.prototypeCell.screenshotsCollectionView.bounds.width @@ -302,6 +306,7 @@ extension BrowseViewController: UICollectionViewDelegateFlowLayout let screenshotHeight = screenshotWidth * aspectRatio let heightConstraint = self.prototypeCell.screenshotsCollectionView.heightAnchor.constraint(equalToConstant: screenshotHeight) + heightConstraint.priority = .defaultHigh // Prevent temporary unsatisfiable constraints error. heightConstraint.isActive = true defer { heightConstraint.isActive = false } diff --git a/AltStore/Components/AppBannerView.swift b/AltStore/Components/AppBannerView.swift index 3187fbd9..4e9c6802 100644 --- a/AltStore/Components/AppBannerView.swift +++ b/AltStore/Components/AppBannerView.swift @@ -11,16 +11,27 @@ import Roxas class AppBannerView: RSTNibView { + private var originalTintColor: UIColor? + @IBOutlet var titleLabel: UILabel! @IBOutlet var subtitleLabel: UILabel! @IBOutlet var iconImageView: AppIconImageView! @IBOutlet var button: PillButton! + @IBOutlet var buttonLabel: UILabel! @IBOutlet var betaBadgeView: UIView! + @IBOutlet var backgroundEffectView: UIVisualEffectView! + @IBOutlet private var vibrancyView: UIVisualEffectView! + override func tintColorDidChange() { super.tintColorDidChange() + if self.tintAdjustmentMode != .dimmed + { + self.originalTintColor = self.tintColor + } + self.update() } } @@ -32,9 +43,7 @@ private extension AppBannerView self.clipsToBounds = true self.layer.cornerRadius = 22 - self.subtitleLabel.textColor = self.tintColor - self.button.tintColor = self.tintColor - - self.backgroundColor = self.tintColor.withAlphaComponent(0.1) + self.subtitleLabel.textColor = self.originalTintColor ?? self.tintColor + self.backgroundEffectView.backgroundColor = self.originalTintColor ?? self.tintColor } } diff --git a/AltStore/Components/AppBannerView.xib b/AltStore/Components/AppBannerView.xib index 932629ec..7c6634f6 100644 --- a/AltStore/Components/AppBannerView.xib +++ b/AltStore/Components/AppBannerView.xib @@ -1,21 +1,23 @@ - - - - + + - + + + + + @@ -23,6 +25,15 @@ + + + + + + + + + @@ -34,54 +45,97 @@ - + - - + + - + + + + + - + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - + + + + + + + + + + + + diff --git a/AltStore/Components/AppIconImageView.swift b/AltStore/Components/AppIconImageView.swift index 2a8c6492..08371e8a 100644 --- a/AltStore/Components/AppIconImageView.swift +++ b/AltStore/Components/AppIconImageView.swift @@ -19,13 +19,16 @@ class AppIconImageView: UIImageView self.backgroundColor = .white - self.layer.borderWidth = 0.5 - self.layer.borderColor = self.tintColor.cgColor - - // Allows us to match system look for app icons. - if self.layer.responds(to: Selector(("continuousCorners"))) + if #available(iOS 13, *) { - self.layer.setValue(true, forKey: "continuousCorners") + self.layer.cornerCurve = .continuous + } + else + { + if self.layer.responds(to: Selector(("continuousCorners"))) + { + self.layer.setValue(true, forKey: "continuousCorners") + } } } @@ -37,11 +40,4 @@ class AppIconImageView: UIImageView let radius = self.bounds.height / 5 self.layer.cornerRadius = radius } - - override func tintColorDidChange() - { - super.tintColorDidChange() - - self.layer.borderColor = self.tintColor.cgColor - } } diff --git a/AltStore/Components/ForwardingNavigationController.swift b/AltStore/Components/ForwardingNavigationController.swift new file mode 100644 index 00000000..6af0f806 --- /dev/null +++ b/AltStore/Components/ForwardingNavigationController.swift @@ -0,0 +1,20 @@ +// +// ForwardingNavigationController.swift +// AltStore +// +// Created by Riley Testut on 10/24/19. +// Copyright © 2019 Riley Testut. All rights reserved. +// + +import UIKit + +class ForwardingNavigationController: UINavigationController +{ + override var childForStatusBarStyle: UIViewController? { + return self.topViewController + } + + override var childForStatusBarHidden: UIViewController? { + return self.topViewController + } +} diff --git a/AltStore/Components/Keychain.swift b/AltStore/Components/Keychain.swift index df82eb60..a6705aa0 100644 --- a/AltStore/Components/Keychain.swift +++ b/AltStore/Components/Keychain.swift @@ -11,11 +11,68 @@ import KeychainAccess import AltSign +@propertyWrapper +struct KeychainItem +{ + let key: String + + var wrappedValue: Value? { + get { + switch Value.self + { + case is Data.Type: return try? Keychain.shared.keychain.getData(self.key) as? Value + case is String.Type: return try? Keychain.shared.keychain.getString(self.key) as? Value + default: return nil + } + } + set { + switch Value.self + { + case is Data.Type: Keychain.shared.keychain[data: self.key] = newValue as? Data + case is String.Type: Keychain.shared.keychain[self.key] = newValue as? String + default: break + } + } + } + + init(key: String) + { + self.key = key + } +} + class Keychain { static let shared = Keychain() - private let keychain = KeychainAccess.Keychain(service: "com.rileytestut.AltStore").accessibility(.afterFirstUnlock).synchronizable(true) + fileprivate let keychain = KeychainAccess.Keychain(service: "com.rileytestut.AltStore").accessibility(.afterFirstUnlock).synchronizable(true) + + @KeychainItem(key: "appleIDEmailAddress") + var appleIDEmailAddress: String? + + @KeychainItem(key: "appleIDPassword") + var appleIDPassword: String? + + @KeychainItem(key: "signingCertificatePrivateKey") + var signingCertificatePrivateKey: Data? + + @KeychainItem(key: "signingCertificateSerialNumber") + var signingCertificateSerialNumber: String? + + @KeychainItem(key: "signingCertificate") + var signingCertificate: Data? + + @KeychainItem(key: "signingCertificatePassword") + var signingCertificatePassword: String? + + @KeychainItem(key: "patreonAccessToken") + var patreonAccessToken: String? + + @KeychainItem(key: "patreonRefreshToken") + var patreonRefreshToken: String? + + @KeychainItem(key: "patreonCreatorAccessToken") + var patreonCreatorAccessToken: String? private init() { @@ -29,66 +86,3 @@ class Keychain self.signingCertificateSerialNumber = nil } } - -extension Keychain -{ - var appleIDEmailAddress: String? { - get { - let emailAddress = try? self.keychain.get("appleIDEmailAddress") - return emailAddress - } - set { - self.keychain["appleIDEmailAddress"] = newValue - } - } - - var appleIDPassword: String? { - get { - let password = try? self.keychain.get("appleIDPassword") - return password - } - set { - self.keychain["appleIDPassword"] = newValue - } - } - - var signingCertificatePrivateKey: Data? { - get { - let privateKey = try? self.keychain.getData("signingCertificatePrivateKey") - return privateKey - } - set { - self.keychain[data: "signingCertificatePrivateKey"] = newValue - } - } - - var signingCertificateSerialNumber: String? { - get { - let serialNumber = try? self.keychain.get("signingCertificateSerialNumber") - return serialNumber - } - set { - self.keychain["signingCertificateSerialNumber"] = newValue - } - } - - var patreonAccessToken: String? { - get { - let accessToken = try? self.keychain.get("patreonAccessToken") - return accessToken - } - set { - self.keychain["patreonAccessToken"] = newValue - } - } - - var patreonRefreshToken: String? { - get { - let refreshToken = try? self.keychain.get("patreonRefreshToken") - return refreshToken - } - set { - self.keychain["patreonRefreshToken"] = newValue - } - } -} diff --git a/AltStore/Components/NavigationBar.swift b/AltStore/Components/NavigationBar.swift index 890813c1..a57a2599 100644 --- a/AltStore/Components/NavigationBar.swift +++ b/AltStore/Components/NavigationBar.swift @@ -32,19 +32,52 @@ class NavigationBar: UINavigationBar private func initialize() { - self.shadowImage = UIImage() - - if let tintColor = self.barTintColor + if #available(iOS 13, *) { - self.backgroundColorView.backgroundColor = tintColor + let standardAppearance = UINavigationBarAppearance() + standardAppearance.configureWithDefaultBackground() + standardAppearance.shadowColor = nil - // Top = -50 to cover status bar area above navigation bar on any device. - // Bottom = -1 to prevent a flickering gray line from appearing. - self.addSubview(self.backgroundColorView, pinningEdgesWith: UIEdgeInsets(top: -50, left: 0, bottom: -1, right: 0)) + let edgeAppearance = UINavigationBarAppearance() + edgeAppearance.configureWithOpaqueBackground() + edgeAppearance.backgroundColor = self.barTintColor + edgeAppearance.shadowColor = nil + + if let tintColor = self.barTintColor + { + let textAttributes = [NSAttributedString.Key.foregroundColor: UIColor.white] + + standardAppearance.backgroundColor = tintColor + standardAppearance.titleTextAttributes = textAttributes + standardAppearance.largeTitleTextAttributes = textAttributes + + edgeAppearance.titleTextAttributes = textAttributes + edgeAppearance.largeTitleTextAttributes = textAttributes + } + else + { + standardAppearance.backgroundColor = nil + } + + self.scrollEdgeAppearance = edgeAppearance + self.standardAppearance = standardAppearance } else { - self.barTintColor = .white + self.shadowImage = UIImage() + + if let tintColor = self.barTintColor + { + self.backgroundColorView.backgroundColor = tintColor + + // Top = -50 to cover status bar area above navigation bar on any device. + // Bottom = -1 to prevent a flickering gray line from appearing. + self.addSubview(self.backgroundColorView, pinningEdgesWith: UIEdgeInsets(top: -50, left: 0, bottom: -1, right: 0)) + } + else + { + self.barTintColor = .white + } } } diff --git a/AltStore/Components/PillButton.swift b/AltStore/Components/PillButton.swift index e6f464ca..c9483ee8 100644 --- a/AltStore/Components/PillButton.swift +++ b/AltStore/Components/PillButton.swift @@ -11,13 +11,15 @@ import UIKit class PillButton: UIButton { var progress: Progress? { - didSet { + didSet { self.progressView.progress = Float(self.progress?.fractionCompleted ?? 0) self.progressView.observedProgress = self.progress let isUserInteractionEnabled = self.isUserInteractionEnabled self.isIndicatingActivity = (self.progress != nil) self.isUserInteractionEnabled = isUserInteractionEnabled + + self.update() } } @@ -30,12 +32,6 @@ class PillButton: UIButton } } - var isInverted: Bool = false { - didSet { - self.update() - } - } - var countdownDate: Date? { didSet { self.isEnabled = (self.countdownDate == nil) @@ -120,18 +116,18 @@ private extension PillButton { func update() { - if self.isInverted + if self.progress == nil { self.setTitleColor(.white, for: .normal) self.backgroundColor = self.tintColor - self.progressView.progressTintColor = self.tintColor.withAlphaComponent(0.15) } else { self.setTitleColor(self.tintColor, for: .normal) self.backgroundColor = self.tintColor.withAlphaComponent(0.15) - self.progressView.progressTintColor = self.tintColor } + + self.progressView.progressTintColor = self.tintColor } @objc func updateCountdown() diff --git a/AltStore/Components/ToastView.swift b/AltStore/Components/ToastView.swift index c609a421..7a8bb74d 100644 --- a/AltStore/Components/ToastView.swift +++ b/AltStore/Components/ToastView.swift @@ -10,11 +10,35 @@ import Roxas class ToastView: RSTToastView { + var preferredDuration: TimeInterval + override init(text: String, detailText detailedText: String?) { + if detailedText == nil + { + self.preferredDuration = 2.0 + } + else + { + self.preferredDuration = 8.0 + } + super.init(text: text, detailText: detailedText) self.layoutMargins = UIEdgeInsets(top: 6, left: 12, bottom: 6, right: 12) + self.setNeedsLayout() + } + + convenience init(error: Error) + { + if let error = error as? LocalizedError + { + self.init(text: error.localizedDescription, detailText: error.recoverySuggestion ?? error.failureReason) + } + else + { + self.init(text: error.localizedDescription, detailText: nil) + } } required init(coder aDecoder: NSCoder) { @@ -27,4 +51,14 @@ class ToastView: RSTToastView self.layer.cornerRadius = 16 } + + func show(in viewController: UIViewController) + { + self.show(in: viewController.navigationController?.view ?? viewController.view, duration: self.preferredDuration) + } + + override func show(in view: UIView) + { + self.show(in: view, duration: self.preferredDuration) + } } diff --git a/AltStore/Extensions/ALTApplication+AppExtensions.swift b/AltStore/Extensions/ALTApplication+AppExtensions.swift new file mode 100644 index 00000000..3ed8f0d2 --- /dev/null +++ b/AltStore/Extensions/ALTApplication+AppExtensions.swift @@ -0,0 +1,29 @@ +// +// ALTApplication+AppExtensions.swift +// AltStore +// +// Created by Riley Testut on 2/10/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +import AltSign + +extension ALTApplication +{ + var appExtensions: Set { + guard let bundle = Bundle(url: self.fileURL) else { return [] } + + var appExtensions: Set = [] + + if let directory = bundle.builtInPlugInsURL, let enumerator = FileManager.default.enumerator(at: directory, includingPropertiesForKeys: nil, options: [.skipsSubdirectoryDescendants]) + { + for case let fileURL as URL in enumerator where fileURL.pathExtension.lowercased() == "appex" + { + guard let appExtension = ALTApplication(fileURL: fileURL) else { continue } + appExtensions.insert(appExtension) + } + } + + return appExtensions + } +} diff --git a/AltStore/Extensions/UserDefaults+AltStore.swift b/AltStore/Extensions/UserDefaults+AltStore.swift index ba49046a..828989f8 100644 --- a/AltStore/Extensions/UserDefaults+AltStore.swift +++ b/AltStore/Extensions/UserDefaults+AltStore.swift @@ -20,6 +20,8 @@ extension UserDefaults @NSManaged var isDebugModeEnabled: Bool @NSManaged var presentedLaunchReminderNotification: Bool + @NSManaged var legacySideloadedApps: [String]? + func registerDefaults() { self.register(defaults: [#keyPath(UserDefaults.isBackgroundRefreshEnabled): true]) diff --git a/AltStore/Info.plist b/AltStore/Info.plist index 05c14cb4..4df53e85 100644 --- a/AltStore/Info.plist +++ b/AltStore/Info.plist @@ -3,7 +3,7 @@ ALTDeviceID - 1c3416b7b0ab68773e6e7eb7f0d110f7c9353acc + 00008030-001948590202802E ALTServerID 1AAAB6FD-E8CE-4B70-8F26-4073215C03B0 CFBundleDevelopmentRegion @@ -36,7 +36,7 @@ CFBundlePackageType APPL CFBundleShortVersionString - 1.0.1 + $(MARKETING_VERSION) CFBundleURLTypes @@ -120,7 +120,5 @@ - UIUserInterfaceStyle - Light diff --git a/AltStore/LaunchViewController.swift b/AltStore/LaunchViewController.swift index 7cb18eb9..53d4e7a9 100644 --- a/AltStore/LaunchViewController.swift +++ b/AltStore/LaunchViewController.swift @@ -11,6 +11,10 @@ import Roxas class LaunchViewController: RSTLaunchViewController { + private var didFinishLaunching = false + + private var destinationViewController: UIViewController! + override var launchConditions: [RSTLaunchCondition] { let isDatabaseStarted = RSTLaunchCondition(condition: { DatabaseManager.shared.isStarted }) { (completionHandler) in DatabaseManager.shared.start(completionHandler: completionHandler) @@ -18,6 +22,22 @@ class LaunchViewController: RSTLaunchViewController return [isDatabaseStarted] } + + override var childForStatusBarStyle: UIViewController? { + return self.children.first + } + + override var childForStatusBarHidden: UIViewController? { + return self.children.first + } + + override func viewDidLoad() + { + super.viewDidLoad() + + // Create destinationViewController now so view controllers can register for receiving Notifications. + self.destinationViewController = self.storyboard!.instantiateViewController(withIdentifier: "tabBarController") as! TabBarController + } } extension LaunchViewController @@ -44,9 +64,23 @@ extension LaunchViewController { super.finishLaunching() + guard !self.didFinishLaunching else { return } + AppManager.shared.update() PatreonAPI.shared.refreshPatreonAccount() - self.performSegue(withIdentifier: "finishLaunching", sender: nil) + // Add view controller as child (rather than presenting modally) + // so tint adjustment + card presentations works correctly. + self.destinationViewController.view.frame = CGRect(x: 0, y: 0, width: self.view.bounds.width, height: self.view.bounds.height) + self.destinationViewController.view.alpha = 0.0 + self.addChild(self.destinationViewController) + self.view.addSubview(self.destinationViewController.view, pinningEdgesWith: .zero) + self.destinationViewController.didMove(toParent: self) + + UIView.animate(withDuration: 0.2) { + self.destinationViewController.view.alpha = 1.0 + } + + self.didFinishLaunching = true } } diff --git a/AltStore/Managing Apps/AppManager.swift b/AltStore/Managing Apps/AppManager.swift index 993ff6d8..1f384bf3 100644 --- a/AltStore/Managing Apps/AppManager.swift +++ b/AltStore/Managing Apps/AppManager.swift @@ -9,6 +9,7 @@ import Foundation import UIKit import UserNotifications +import MobileCoreServices import AltSign import AltKit @@ -20,6 +21,8 @@ extension AppManager static let didFetchSourceNotification = Notification.Name("com.altstore.AppManager.didFetchSource") static let expirationWarningNotificationID = "altstore-expiration-warning" + + static let whitelistedSideloadingBundleIDs: Set = ["science.xnu.undecimus"] } class AppManager @@ -55,16 +58,32 @@ extension AppManager do { let installedApps = try context.fetch(fetchRequest) - for app in installedApps where app.storeApp != nil + + if UserDefaults.standard.legacySideloadedApps == nil { + // First time updating apps since updating AltStore to use custom UTIs, + // so cache all existing apps temporarily to prevent us from accidentally + // deleting them due to their custom UTI not existing (yet). + let apps = installedApps.map { $0.bundleIdentifier } + UserDefaults.standard.legacySideloadedApps = apps + } + + let legacySideloadedApps = Set(UserDefaults.standard.legacySideloadedApps ?? []) + + for app in installedApps + { + let uti = UTTypeCopyDeclaration(app.installedAppUTI as CFString)?.takeRetainedValue() as NSDictionary? + if app.bundleIdentifier == StoreApp.altstoreAppID { self.scheduleExpirationWarningLocalNotification(for: app) } else { - if !UIApplication.shared.canOpenURL(app.openAppURL) + if uti == nil && !legacySideloadedApps.contains(app.bundleIdentifier) { + // This UTI is not declared by any apps, which means this app has been deleted by the user. + // This app is also not a legacy sideloaded app, so we can assume it's fine to delete it. context.delete(app) } } @@ -80,13 +99,37 @@ extension AppManager #endif } - func authenticate(presentingViewController: UIViewController?, completionHandler: @escaping (Result) -> Void) + @discardableResult + func authenticate(presentingViewController: UIViewController?, completionHandler: @escaping (Result<(ALTSigner, ALTAppleAPISession), Error>) -> Void) -> OperationGroup { - let authenticationOperation = AuthenticationOperation(presentingViewController: presentingViewController) + let group = OperationGroup() + + let findServerOperation = FindServerOperation(group: group) + findServerOperation.resultHandler = { (result) in + switch result + { + case .failure(let error): group.error = error + case .success(let server): group.server = server + } + } + self.operationQueue.addOperation(findServerOperation) + + let authenticationOperation = AuthenticationOperation(group: group, presentingViewController: presentingViewController) authenticationOperation.resultHandler = { (result) in + switch result + { + case .failure(let error): group.error = error + case .success(let signer, let session): + group.signer = signer + group.session = session + } + completionHandler(result) } + authenticationOperation.addDependency(findServerOperation) self.operationQueue.addOperation(authenticationOperation) + + return group } } @@ -114,6 +157,23 @@ extension AppManager self.operationQueue.addOperation(fetchSourceOperation) } } + + func fetchAppIDs(completionHandler: @escaping (Result<([AppID], NSManagedObjectContext), Error>) -> Void) + { + var group: OperationGroup! + group = self.authenticate(presentingViewController: nil) { (result) in + switch result + { + case .failure(let error): + completionHandler(.failure(error)) + + case .success: + let fetchAppIDsOperation = FetchAppIDsOperation(group: group) + fetchAppIDsOperation.resultHandler = completionHandler + self.operationQueue.addOperation(fetchAppIDsOperation) + } + } + } } extension AppManager @@ -149,7 +209,7 @@ extension AppManager func refresh(_ installedApps: [InstalledApp], presentingViewController: UIViewController?, group: OperationGroup? = nil) -> OperationGroup { - let apps = installedApps.filter { self.refreshProgress(for: $0) == nil } + let apps = installedApps.filter { self.refreshProgress(for: $0) == nil || self.refreshProgress(for: $0)?.isCancelled == true } let group = self.install(apps, forceDownload: false, presentingViewController: presentingViewController, group: group) @@ -183,18 +243,6 @@ private extension AppManager let group = group ?? OperationGroup() var operations = [Operation]() - - /* Authenticate */ - let authenticationOperation = AuthenticationOperation(presentingViewController: presentingViewController) - authenticationOperation.resultHandler = { (result) in - switch result - { - case .failure(let error): group.error = error - case .success(let signer): group.signer = signer - } - } - operations.append(authenticationOperation) - /* Find Server */ let findServerOperation = FindServerOperation(group: group) findServerOperation.resultHandler = { (result) in @@ -204,9 +252,55 @@ private extension AppManager case .success(let server): group.server = server } } - findServerOperation.addDependency(authenticationOperation) operations.append(findServerOperation) + let authenticationOperation: AuthenticationOperation? + + if group.signer == nil || group.session == nil + { + /* Authenticate */ + let operation = AuthenticationOperation(group: group, presentingViewController: presentingViewController) + operation.resultHandler = { (result) in + switch result + { + case .failure(let error): group.error = error + case .success(let signer, let session): + group.signer = signer + group.session = session + } + } + operations.append(operation) + operation.addDependency(findServerOperation) + + authenticationOperation = operation + } + else + { + authenticationOperation = nil + } + + let refreshAnisetteDataOperation = FetchAnisetteDataOperation(group: group) + refreshAnisetteDataOperation.resultHandler = { (result) in + switch result + { + case .failure(let error): group.error = error + case .success(let anisetteData): group.session?.anisetteData = anisetteData + } + } + refreshAnisetteDataOperation.addDependency(authenticationOperation ?? findServerOperation) + operations.append(refreshAnisetteDataOperation) + + /* Prepare Developer Account */ + let prepareDeveloperAccountOperation = PrepareDeveloperAccountOperation(group: group) + prepareDeveloperAccountOperation.resultHandler = { (result) in + switch result + { + case .failure(let error): group.error = error + case .success: break + } + } + prepareDeveloperAccountOperation.addDependency(refreshAnisetteDataOperation) + operations.append(prepareDeveloperAccountOperation) for app in apps { @@ -220,7 +314,7 @@ private extension AppManager guard let resignedApp = self.process(result, context: context) else { return } context.resignedApp = resignedApp } - resignAppOperation.addDependency(findServerOperation) + resignAppOperation.addDependency(prepareDeveloperAccountOperation) progress.addChild(resignAppOperation.progress, withPendingUnitCount: 20) operations.append(resignAppOperation) @@ -267,8 +361,8 @@ private extension AppManager /* Send */ let sendAppOperation = SendAppOperation(context: context) sendAppOperation.resultHandler = { (result) in - guard let connection = self.process(result, context: context) else { return } - context.connection = connection + guard let installationConnection = self.process(result, context: context) else { return } + context.installationConnection = installationConnection } progress.addChild(sendAppOperation.progress, withPendingUnitCount: 10) sendAppOperation.addDependency(resignAppOperation) @@ -312,6 +406,28 @@ private extension AppManager group.set(progress, for: app) } + // Refresh anisette data after downloading all apps to prevent session from expiring. + for case let downloadOperation as DownloadAppOperation in operations + { + refreshAnisetteDataOperation.addDependency(downloadOperation) + } + + /* Cache App IDs */ + let fetchAppIDsOperation = FetchAppIDsOperation(group: group) + fetchAppIDsOperation.resultHandler = { (result) in + do + { + let (_, context) = try result.get() + try context.save() + } + catch + { + print("Failed to fetch App IDs.", error) + } + } + operations.forEach { fetchAppIDsOperation.addDependency($0) } + operations.append(fetchAppIDsOperation) + group.addOperations(operations) return group @@ -344,7 +460,11 @@ private extension AppManager guard !context.isFinished else { return } context.isFinished = true - self.refreshProgress[context.bundleIdentifier] = nil + if let progress = self.refreshProgress[context.bundleIdentifier], progress == context.group.progress(forAppWithBundleIdentifier: context.bundleIdentifier) + { + // Only remove progress if it hasn't been replaced by another one. + self.refreshProgress[context.bundleIdentifier] = nil + } if let error = context.error { @@ -376,10 +496,13 @@ private extension AppManager do { try installedApp.managedObjectContext?.save() } catch { print("Error saving installed app.", error) } } - } - - do { try FileManager.default.removeItem(at: context.temporaryDirectory) } - catch { print("Failed to remove temporary directory.", error) } + + if let index = UserDefaults.standard.legacySideloadedApps?.firstIndex(of: installedApp.bundleIdentifier) + { + // No longer a legacy sideloaded app, so remove it from cached list. + UserDefaults.standard.legacySideloadedApps?.remove(at: index) + } + } print("Finished operation!", context.bundleIdentifier) diff --git a/AltStore/Model/Account.swift b/AltStore/Model/Account.swift index 5a6a732f..a143a3f6 100644 --- a/AltStore/Model/Account.swift +++ b/AltStore/Model/Account.swift @@ -44,6 +44,11 @@ class Account: NSManagedObject, Fetchable { super.init(entity: Account.entity(), insertInto: context) + self.update(account: account) + } + + func update(account: ALTAccount) + { self.appleID = account.appleID self.identifier = account.identifier diff --git a/AltStore/Model/AltStore.xcdatamodeld/.xccurrentversion b/AltStore/Model/AltStore.xcdatamodeld/.xccurrentversion index d4afd65c..79452ae5 100644 --- a/AltStore/Model/AltStore.xcdatamodeld/.xccurrentversion +++ b/AltStore/Model/AltStore.xcdatamodeld/.xccurrentversion @@ -3,6 +3,6 @@ _XCCurrentVersionName - AltStore 2.xcdatamodel + AltStore 4.xcdatamodel diff --git a/AltStore/Model/AltStore.xcdatamodeld/AltStore 3.xcdatamodel/contents b/AltStore/Model/AltStore.xcdatamodeld/AltStore 3.xcdatamodel/contents new file mode 100644 index 00000000..7f9e32a5 --- /dev/null +++ b/AltStore/Model/AltStore.xcdatamodeld/AltStore 3.xcdatamodel/contents @@ -0,0 +1,152 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/AltStore/Model/AltStore.xcdatamodeld/AltStore 4.xcdatamodel/contents b/AltStore/Model/AltStore.xcdatamodeld/AltStore 4.xcdatamodel/contents new file mode 100644 index 00000000..4b75b6dd --- /dev/null +++ b/AltStore/Model/AltStore.xcdatamodeld/AltStore 4.xcdatamodel/contents @@ -0,0 +1,167 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/AltStore/Model/AppID.swift b/AltStore/Model/AppID.swift new file mode 100644 index 00000000..faf3aabb --- /dev/null +++ b/AltStore/Model/AppID.swift @@ -0,0 +1,52 @@ +// +// AppID.swift +// AltStore +// +// Created by Riley Testut on 1/27/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +import Foundation +import CoreData + +import AltSign + +@objc(AppID) +class AppID: NSManagedObject, Fetchable +{ + /* Properties */ + @NSManaged var name: String + @NSManaged var identifier: String + @NSManaged var bundleIdentifier: String + @NSManaged var features: [ALTFeature: Any] + @NSManaged var expirationDate: Date? + + /* Relationships */ + @NSManaged private(set) var team: Team? + + private override init(entity: NSEntityDescription, insertInto context: NSManagedObjectContext?) + { + super.init(entity: entity, insertInto: context) + } + + init(_ appID: ALTAppID, team: Team, context: NSManagedObjectContext) + { + super.init(entity: AppID.entity(), insertInto: context) + + self.name = appID.name + self.identifier = appID.identifier + self.bundleIdentifier = appID.bundleIdentifier + self.features = appID.features + self.expirationDate = appID.expirationDate + + self.team = team + } +} + +extension AppID +{ + @nonobjc class func fetchRequest() -> NSFetchRequest + { + return NSFetchRequest(entityName: "AppID") + } +} diff --git a/AltStore/Model/DatabaseManager.swift b/AltStore/Model/DatabaseManager.swift index 5dd9ecc7..f5d65222 100644 --- a/AltStore/Model/DatabaseManager.swift +++ b/AltStore/Model/DatabaseManager.swift @@ -194,13 +194,7 @@ private extension DatabaseManager } // Must go after comparing versions to see if we need to update our cached AltStore app bundle. - installedApp.version = localApp.version - - if let provisioningProfile = localApp.provisioningProfile - { - installedApp.refreshedDate = provisioningProfile.creationDate - installedApp.expirationDate = provisioningProfile.expirationDate - } + installedApp.update(resignedApp: localApp) do { diff --git a/AltStore/Model/InstalledApp.swift b/AltStore/Model/InstalledApp.swift index 4a7854e2..e2b5dd73 100644 --- a/AltStore/Model/InstalledApp.swift +++ b/AltStore/Model/InstalledApp.swift @@ -11,8 +11,20 @@ import CoreData import AltSign +protocol InstalledAppProtocol: Fetchable +{ + var name: String { get } + var bundleIdentifier: String { get } + var resignedBundleIdentifier: String { get } + var version: String { get } + + var refreshedDate: Date { get } + var expirationDate: Date { get } + var installedDate: Date { get } +} + @objc(InstalledApp) -class InstalledApp: NSManagedObject, Fetchable +class InstalledApp: NSManagedObject, InstalledAppProtocol { /* Properties */ @NSManaged var name: String @@ -22,9 +34,12 @@ class InstalledApp: NSManagedObject, Fetchable @NSManaged var refreshedDate: Date @NSManaged var expirationDate: Date + @NSManaged var installedDate: Date /* Relationships */ @NSManaged var storeApp: StoreApp? + @NSManaged var team: Team? + @NSManaged var appExtensions: Set var isSideloaded: Bool { return self.storeApp == nil @@ -39,10 +54,21 @@ class InstalledApp: NSManagedObject, Fetchable { super.init(entity: InstalledApp.entity(), insertInto: context) - self.name = resignedApp.name self.bundleIdentifier = originalBundleIdentifier - self.resignedBundleIdentifier = resignedApp.bundleIdentifier + self.refreshedDate = Date() + self.installedDate = Date() + + self.expirationDate = self.refreshedDate.addingTimeInterval(60 * 60 * 24 * 7) // Rough estimate until we get real values from provisioning profile. + + self.update(resignedApp: resignedApp) + } + + func update(resignedApp: ALTApplication) + { + self.name = resignedApp.name + + self.resignedBundleIdentifier = resignedApp.bundleIdentifier self.version = resignedApp.version if let provisioningProfile = resignedApp.provisioningProfile @@ -50,11 +76,6 @@ class InstalledApp: NSManagedObject, Fetchable self.refreshedDate = provisioningProfile.creationDate self.expirationDate = provisioningProfile.expirationDate } - else - { - self.refreshedDate = Date() - self.expirationDate = self.refreshedDate.addingTimeInterval(60 * 60 * 24 * 7) // Rough estimate until we get real values from provisioning profile. - } } } @@ -187,6 +208,12 @@ extension InstalledApp return directoryURL } + class func installedAppUTI(forBundleIdentifier bundleIdentifier: String) -> String + { + let installedAppUTI = "io.altstore.Installed." + bundleIdentifier + return installedAppUTI + } + var directoryURL: URL { return InstalledApp.directoryURL(for: self) } @@ -198,4 +225,8 @@ extension InstalledApp var refreshedIPAURL: URL { return InstalledApp.refreshedIPAURL(for: self) } + + var installedAppUTI: String { + return InstalledApp.installedAppUTI(forBundleIdentifier: self.resignedBundleIdentifier) + } } diff --git a/AltStore/Model/InstalledExtension.swift b/AltStore/Model/InstalledExtension.swift new file mode 100644 index 00000000..f766fa5b --- /dev/null +++ b/AltStore/Model/InstalledExtension.swift @@ -0,0 +1,70 @@ +// +// InstalledExtension.swift +// AltStore +// +// Created by Riley Testut on 1/7/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +import Foundation +import CoreData + +import AltSign + +@objc(InstalledExtension) +class InstalledExtension: NSManagedObject, InstalledAppProtocol +{ + /* Properties */ + @NSManaged var name: String + @NSManaged var bundleIdentifier: String + @NSManaged var resignedBundleIdentifier: String + @NSManaged var version: String + + @NSManaged var refreshedDate: Date + @NSManaged var expirationDate: Date + @NSManaged var installedDate: Date + + /* Relationships */ + @NSManaged var parentApp: InstalledApp? + + private override init(entity: NSEntityDescription, insertInto context: NSManagedObjectContext?) + { + super.init(entity: entity, insertInto: context) + } + + init(resignedAppExtension: ALTApplication, originalBundleIdentifier: String, context: NSManagedObjectContext) + { + super.init(entity: InstalledExtension.entity(), insertInto: context) + + self.bundleIdentifier = originalBundleIdentifier + + self.refreshedDate = Date() + self.installedDate = Date() + + self.expirationDate = self.refreshedDate.addingTimeInterval(60 * 60 * 24 * 7) // Rough estimate until we get real values from provisioning profile. + + self.update(resignedAppExtension: resignedAppExtension) + } + + func update(resignedAppExtension: ALTApplication) + { + self.name = resignedAppExtension.name + + self.resignedBundleIdentifier = resignedAppExtension.bundleIdentifier + self.version = resignedAppExtension.version + + if let provisioningProfile = resignedAppExtension.provisioningProfile + { + self.refreshedDate = provisioningProfile.creationDate + self.expirationDate = provisioningProfile.expirationDate + } + } +} + +extension InstalledExtension +{ + @nonobjc class func fetchRequest() -> NSFetchRequest + { + return NSFetchRequest(entityName: "InstalledExtension") + } +} diff --git a/AltStore/Model/Migrations/Mapping Models/AltStore2ToAltStore3.xcmappingmodel/xcmapping.xml b/AltStore/Model/Migrations/Mapping Models/AltStore2ToAltStore3.xcmappingmodel/xcmapping.xml new file mode 100644 index 00000000..d1a053a9 --- /dev/null +++ b/AltStore/Model/Migrations/Mapping Models/AltStore2ToAltStore3.xcmappingmodel/xcmapping.xml @@ -0,0 +1,487 @@ + + + + + + 134481920 + 15C5E1F8-8238-41F2-A129-F1FBC710D58B + 189 + + + + NSPersistenceFrameworkVersion + 977 + NSStoreModelVersionHashes + + XDDevAttributeMapping + + 0plcXXRN7XHKl5CcF+fwriFmUpON3ZtcI/AfK748aWc= + + XDDevEntityMapping + + qeN1Ym3TkWN1G6dU9RfX6Kd2ccEvcDVWHpd3LpLgboI= + + XDDevMappingModel + + EqtMzvRnVZWkXwBHu4VeVGy8UyoOe+bi67KC79kphlQ= + + XDDevPropertyMapping + + XN33V44TTGY4JETlMoOB5yyTKxB+u4slvDIinv0rtGA= + + XDDevRelationshipMapping + + akYY9LhehVA/mCb4ATLWuI9XGLcjpm14wWL1oEBtIcs= + + + NSStoreModelVersionHashesDigest + +Hmc2uYZK6og+Pvx5GUJ7oW75UG4V/ksQanTjfTKUnxyGWJRMtB5tIRgVwGsrd7lz/QR57++wbvWsr6nxwyS0A== + NSStoreModelVersionHashesVersion + 3 + NSStoreModelVersionIdentifiers + + + + + + + + + 1 + installedApps + + + + YnBsaXN0MDDUAQIDBAUGBwpYJHZlcnNpb25ZJGFyY2hpdmVyVCR0b3BYJG9iamVjdHMSAAGGoF8Q +D05TS2V5ZWRBcmNoaXZlctEICVRyb290gAGsCwwXGB0eJiswMTQ4VSRudWxs1Q0ODxAREhMUFRZZTlNPcGVyYW5kXk5TU2VsZWN0b3JOYW1lXxAQTlNFeHByZXNzaW9uVHlwZVtOU0FyZ3VtZW50c1YkY2xhc3OAA4ACEASABoALXxAQdmFsdWVGb3JLZXlQYXRoOtMZDxEaGxxaTlNWYXJpYWJsZYAEEAKABVZzb3VyY2XSHyAhIlokY2xhc3NuYW1lWCRjbGFzc2VzXxAUTlNWYXJpYWJsZUV4cHJlc3Npb26jIyQlXxAUTlNWYXJpYWJsZUV4cHJlc3Npb25cTlNFeHByZXNzaW9uWE5TT2JqZWN00icRKCpaTlMub2JqZWN0c6EpgAeACtMRDywtLi9ZTlNLZXlQYXRogAkQCoAIXXJlZnJlc2hlZERhdGXSHyAyM18QHE5TS2V5UGF0aFNwZWNpZmllckV4cHJlc3Npb26jMiQl0h8gNTZeTlNNdXRhYmxlQXJyYXmjNTclV05TQXJyYXnSHyA5Ol8QE05TS2V5UGF0aEV4cHJlc3Npb26kOTskJV8QFE5TRnVuY3Rpb25FeHByZXNzaW9uAAgAEQAaACQAKQAyADcASQBMAFEAUwBgAGYAcQB7AIoAnQCpALAAsgC0ALYAuAC6AM0A1ADfAOEA4wDlAOwA8QD8AQUBHAEgATcBRAFNAVIBXQFfAWEBYwFqAXQBdgF4AXoBiAGNAawBsAG1AcQByAHQAdUB6wHwAAAAAAAAAgEAAAAAAAAAPAAAAAAAAAAAAAAAAAAAAgc= + + installedDate + + + + caption + + + + isSuccess + + + + screenshotURLs + + + + resignedBundleIdentifier + + + + Undefined + 6 + InstalledExtension + 1 + + + + + + name + + + + RefreshAttempt + Undefined + 7 + RefreshAttempt + 1 + + + + + + bundleIdentifier + + + + PatreonAccount + Undefined + 3 + PatreonAccount + 1 + + + + + + versionDate + + + + name + + + + 1 + newsItems + + + + lastName + + + + NewsItem + Undefined + 4 + NewsItem + 1 + + + + + + version + + + + usageDescription + + + + size + + + + resignedBundleIdentifier + + + + 1 + app + + + + downloadURL + + + + identifier + + + + externalURL + + + + type + + + + StoreApp + Undefined + 9 + StoreApp + 1 + + + + + + 1 + newsItems + + + + versionDescription + + + + Team + Undefined + 2 + Team + 1 + + + + + + expirationDate + + + + firstName + + + + refreshedDate + + + + installedDate + + + + 1 + permissions + + + + InstalledAppToInstalledAppMigrationPolicy + InstalledApp + Undefined + 5 + InstalledApp + 1 + + + + + + sortIndex + + + + version + + + + appleID + + + + expirationDate + + + + Account + Undefined + 1 + Account + 1 + + + + + + sourceURL + + + + errorDescription + + + + AltStore/Model/AltStore.xcdatamodeld/AltStore 2.xcdatamodel + YnBsaXN0MDDUAAEAAgADAAQABQAGAAcAClgkdmVyc2lvblkkYXJjaGl2ZXJUJHRvcFgkb2JqZWN0 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 + + AltStore/Model/AltStore.xcdatamodeld/AltStore 3.xcdatamodel + YnBsaXN0MDDUAAEAAgADAAQABQAGAAcAClgkdmVyc2lvblkkYXJjaGl2ZXJUJHRvcFgkb2JqZWN0 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 + + + + + developerName + + + + tintColor + + + + name + + + + 1 + account + + + + firstName + + + + appID + + + + title + + + + 1 + appExtensions + + + + identifier + + + + AppPermission + Undefined + 8 + AppPermission + 1 + + + + + + isBeta + + + + 1 + storeApp + + + + identifier + + + + isActiveAccount + + + + type + + + + 1 + source + + + + 1 + source + + + + bundleIdentifier + + + + 1 + storeApp + + + + name + + + + 1 + parentApp + + + + iconURL + + + + refreshedDate + + + + Source + Undefined + 10 + Source + 1 + + + + + + identifier + + + + identifier + + + + localizedDescription + + + + date + + + + version + + + + 1 + installedApp + + + + subtitle + + + + bundleIdentifier + + + + identifier + + + + 1 + teams + + + + sortIndex + + + + 1 + team + + + + 1 + apps + + + + imageURL + + + + isSilent + + + + date + + + + tintColor + + + + isPatron + + + + name + + + + isActiveTeam + + + + name + + + \ No newline at end of file diff --git a/AltStore/Model/Migrations/Mapping Models/AltStore3ToAltStore4.xcmappingmodel/xcmapping.xml b/AltStore/Model/Migrations/Mapping Models/AltStore3ToAltStore4.xcmappingmodel/xcmapping.xml new file mode 100644 index 00000000..c9e183a8 --- /dev/null +++ b/AltStore/Model/Migrations/Mapping Models/AltStore3ToAltStore4.xcmappingmodel/xcmapping.xml @@ -0,0 +1,523 @@ + + + + + + 134481920 + 0BF6B5E3-8DE8-45A2-BF07-6ADDDEC5D44C + 197 + + + + NSPersistenceFrameworkVersion + 977 + NSStoreModelVersionHashes + + XDDevAttributeMapping + + 0plcXXRN7XHKl5CcF+fwriFmUpON3ZtcI/AfK748aWc= + + XDDevEntityMapping + + qeN1Ym3TkWN1G6dU9RfX6Kd2ccEvcDVWHpd3LpLgboI= + + XDDevMappingModel + + EqtMzvRnVZWkXwBHu4VeVGy8UyoOe+bi67KC79kphlQ= + + XDDevPropertyMapping + + XN33V44TTGY4JETlMoOB5yyTKxB+u4slvDIinv0rtGA= + + XDDevRelationshipMapping + + akYY9LhehVA/mCb4ATLWuI9XGLcjpm14wWL1oEBtIcs= + + + NSStoreModelVersionHashesDigest + +Hmc2uYZK6og+Pvx5GUJ7oW75UG4V/ksQanTjfTKUnxyGWJRMtB5tIRgVwGsrd7lz/QR57++wbvWsr6nxwyS0A== + NSStoreModelVersionHashesVersion + 3 + NSStoreModelVersionIdentifiers + + + + + + + + + subtitle + + + + expirationDate + + + + version + + + + name + + + + versionDescription + + + + refreshedDate + + + + Account + Undefined + 6 + Account + 1 + + + + + + isActiveAccount + + + + resignedBundleIdentifier + + + + appID + + + + 1 + parentApp + + + + expirationDate + + + + 1 + installedApp + + + + appleID + + + + AppPermission + Undefined + 10 + AppPermission + 1 + + + + + + InstalledApp + Undefined + 2 + InstalledApp + 1 + + + + + + name + + + + name + + + + Source + Undefined + 9 + Source + 1 + + + + + + 1 + source + + + + developerName + + + + name + + + + identifier + + + + tintColor + + + + StoreApp + Undefined + 11 + StoreApp + 1 + + + + + + 1 + apps + + + + 1 + permissions + + + + caption + + + + type + + + + NewsItem + Undefined + 4 + NewsItem + 1 + + + + + + identifier + + + + resignedBundleIdentifier + + + + AltStore/Model/AltStore.xcdatamodeld/AltStore 3.xcdatamodel + YnBsaXN0MDDUAAEAAgADAAQABQAGAAcAClgkdmVyc2lvblkkYXJjaGl2ZXJUJHRvcFgkb2JqZWN0 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 + + AltStore/Model/AltStore.xcdatamodeld/AltStore 4.xcdatamodel + YnBsaXN0MDDUAAEAAgADAAQABQAGAAcAClgkdmVyc2lvblkkYXJjaGl2ZXJUJHRvcFgkb2JqZWN0 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 + + + + + name + + + + type + + + + 1 + appIDs + + + + identifier + + + + identifier + + + + sortIndex + + + + name + + + + isBeta + + + + installedDate + + + + bundleIdentifier + + + + 1 + newsItems + + + + date + + + + 1 + app + + + + identifier + + + + imageURL + + + + 1 + installedApps + + + + externalURL + + + + installedDate + + + + version + + + + localizedDescription + + + + lastName + + + + firstName + + + + identifier + + + + 1 + team + + + + size + + + + isSuccess + + + + sortIndex + + + + 1 + storeApp + + + + isSilent + + + + isActiveTeam + + + + 1 + teams + + + + date + + + + 1 + storeApp + + + + 1 + appExtensions + + + + firstName + + + + usageDescription + + + + features + + + + versionDate + + + + 1 + source + + + + tintColor + + + + screenshotURLs + + + + downloadURL + + + + title + + + + errorDescription + + + + bundleIdentifier + + + + Team + Undefined + 8 + Team + 1 + + + + + + InstalledExtension + Undefined + 7 + InstalledExtension + 1 + + + + + + iconURL + + + + bundleIdentifier + + + + bundleIdentifier + + + + 1 + team + + + + refreshedDate + + + + 1 + account + + + + Undefined + 3 + AppID + 1 + + + + + + sourceURL + + + + isPatron + + + + RefreshAttempt + Undefined + 5 + RefreshAttempt + 1 + + + + + + PatreonAccount + Undefined + 1 + PatreonAccount + 1 + + + + + + identifier + + + + version + + + + name + + + + 1 + newsItems + + + + expirationDate + + + \ No newline at end of file diff --git a/AltStore/Model/Migrations/Policies/InstalledAppPolicy.swift b/AltStore/Model/Migrations/Policies/InstalledAppPolicy.swift new file mode 100644 index 00000000..78da08e3 --- /dev/null +++ b/AltStore/Model/Migrations/Policies/InstalledAppPolicy.swift @@ -0,0 +1,30 @@ +// +// InstalledAppPolicy.swift +// AltStore +// +// Created by Riley Testut on 1/24/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +import CoreData + +@objc(InstalledAppToInstalledAppMigrationPolicy) +class InstalledAppToInstalledAppMigrationPolicy: NSEntityMigrationPolicy +{ + override func createRelationships(forDestination dInstance: NSManagedObject, in mapping: NSEntityMapping, manager: NSMigrationManager) throws + { + try super.createRelationships(forDestination: dInstance, in: mapping, manager: manager) + + // Entity must be in manager.destinationContext. + let entity = NSEntityDescription.entity(forEntityName: "Team", in: manager.destinationContext) + + let fetchRequest = NSFetchRequest() + fetchRequest.entity = entity + fetchRequest.predicate = NSPredicate(format: "%K == YES", #keyPath(Team.isActiveTeam)) + + let teams = try manager.destinationContext.fetch(fetchRequest) + + // Cannot use NSManagedObject subclasses during migration, so fallback to using KVC instead. + dInstance.setValue(teams.first, forKey: #keyPath(InstalledApp.team)) + } +} diff --git a/AltStore/Model/Source.swift b/AltStore/Model/Source.swift index 93007bb1..6250ee27 100644 --- a/AltStore/Model/Source.swift +++ b/AltStore/Model/Source.swift @@ -11,7 +11,12 @@ import CoreData extension Source { static let altStoreIdentifier = "com.rileytestut.AltStore" + + #if STAGING + static let altStoreSourceURL = URL(string: "https://f000.backblazeb2.com/file/altstore-staging/apps-staging.json")! + #else static let altStoreSourceURL = URL(string: "https://cdn.altstore.io/file/altstore/apps.json")! + #endif } @objc(Source) @@ -22,6 +27,9 @@ class Source: NSManagedObject, Fetchable, Decodable @NSManaged var identifier: String @NSManaged var sourceURL: URL + /* Non-Core Data Properties */ + var userInfo: [ALTSourceUserInfoKey: String]? + /* Relationships */ @objc(apps) @NSManaged private(set) var _apps: NSOrderedSet @objc(newsItems) @NSManaged private(set) var _newsItems: NSOrderedSet @@ -49,6 +57,7 @@ class Source: NSManagedObject, Fetchable, Decodable case name case identifier case sourceURL + case userInfo case apps case news } @@ -69,6 +78,9 @@ class Source: NSManagedObject, Fetchable, Decodable self.identifier = try container.decode(String.self, forKey: .identifier) self.sourceURL = try container.decode(URL.self, forKey: .sourceURL) + let userInfo = try container.decodeIfPresent([String: String].self, forKey: .userInfo) + self.userInfo = userInfo?.reduce(into: [:]) { $0[ALTSourceUserInfoKey($1.key)] = $1.value } + let apps = try container.decodeIfPresent([StoreApp].self, forKey: .apps) ?? [] for (index, app) in apps.enumerated() { diff --git a/AltStore/Model/Team.swift b/AltStore/Model/Team.swift index cdb3ded3..f185de94 100644 --- a/AltStore/Model/Team.swift +++ b/AltStore/Model/Team.swift @@ -17,7 +17,7 @@ extension ALTTeamType switch self { case .free: return NSLocalizedString("Free Developer Account", comment: "") - case .individual: return NSLocalizedString("Individual", comment: "") + case .individual: return NSLocalizedString("Developer", comment: "") case .organization: return NSLocalizedString("Organization", comment: "") case .unknown: fallthrough @unknown default: return NSLocalizedString("Unknown", comment: "") @@ -25,6 +25,11 @@ extension ALTTeamType } } +extension Team +{ + static let maximumFreeAppIDs = 10 +} + @objc(Team) class Team: NSManagedObject, Fetchable { @@ -37,6 +42,8 @@ class Team: NSManagedObject, Fetchable /* Relationships */ @NSManaged private(set) var account: Account! + @NSManaged var installedApps: Set + @NSManaged private(set) var appIDs: Set var altTeam: ALTTeam? @@ -49,13 +56,18 @@ class Team: NSManagedObject, Fetchable { super.init(entity: Team.entity(), insertInto: context) + self.account = account + + self.update(team: team) + } + + func update(team: ALTTeam) + { self.altTeam = team self.name = team.name self.identifier = team.identifier self.type = team.type - - self.account = account } } diff --git a/AltStore/My Apps/MyAppsComponents.swift b/AltStore/My Apps/MyAppsComponents.swift index 3733afce..6fe9e23a 100644 --- a/AltStore/My Apps/MyAppsComponents.swift +++ b/AltStore/My Apps/MyAppsComponents.swift @@ -10,11 +10,18 @@ import UIKit class InstalledAppCollectionViewCell: UICollectionViewCell { - @IBOutlet var appIconImageView: UIImageView! - @IBOutlet var nameLabel: UILabel! - @IBOutlet var developerLabel: UILabel! - @IBOutlet var refreshButton: PillButton! - @IBOutlet var betaBadgeView: UIImageView! + @IBOutlet var bannerView: AppBannerView! + + override func awakeFromNib() + { + super.awakeFromNib() + + self.contentView.autoresizingMask = [.flexibleWidth, .flexibleHeight] + self.contentView.preservesSuperviewLayoutMargins = true + + self.bannerView.buttonLabel.text = NSLocalizedString("Expires in", comment: "") + self.bannerView.buttonLabel.isHidden = false + } } class InstalledAppsCollectionHeaderView: UICollectionReusableView @@ -23,6 +30,24 @@ class InstalledAppsCollectionHeaderView: UICollectionReusableView @IBOutlet var button: UIButton! } +class InstalledAppsCollectionFooterView: UICollectionReusableView +{ + @IBOutlet var textLabel: UILabel! + @IBOutlet var button: UIButton! +} + +class NoUpdatesCollectionViewCell: UICollectionViewCell +{ + @IBOutlet var blurView: UIVisualEffectView! + + override func awakeFromNib() + { + super.awakeFromNib() + + self.contentView.preservesSuperviewLayoutMargins = true + } +} + class UpdatesCollectionHeaderView: UICollectionReusableView { let button = PillButton(type: .system) diff --git a/AltStore/My Apps/MyAppsViewController.swift b/AltStore/My Apps/MyAppsViewController.swift index 605efa85..696eb7b6 100644 --- a/AltStore/My Apps/MyAppsViewController.swift +++ b/AltStore/My Apps/MyAppsViewController.swift @@ -67,6 +67,17 @@ class MyAppsViewController: UICollectionViewController { super.viewDidLoad() + #if !BETA + // Set leftBarButtonItem to invisible UIBarButtonItem so we can still use it + // to show an activity indicator while sideloading whitelisted apps. + self.navigationItem.leftBarButtonItem = UIBarButtonItem(title: "", style: .plain, target: nil, action: nil) + #endif + + if #available(iOS 13.0, *) + { + self.navigationItem.leftBarButtonItem?.activityIndicatorView.style = .medium + } + // Allows us to intercept delegate callbacks. self.updatesDataSource.fetchedResultsController.delegate = self @@ -74,7 +85,6 @@ class MyAppsViewController: UICollectionViewController self.collectionView.prefetchDataSource = self.dataSource self.prototypeUpdateCell = UpdateCollectionViewCell.instantiate(with: UpdateCollectionViewCell.nib!) - self.prototypeUpdateCell.translatesAutoresizingMaskIntoConstraints = false self.prototypeUpdateCell.contentView.translatesAutoresizingMaskIntoConstraints = false self.collectionView.register(UpdateCollectionViewCell.nib, forCellWithReuseIdentifier: "UpdateCell") @@ -85,10 +95,6 @@ class MyAppsViewController: UICollectionViewController self.sideloadingProgressView.progressTintColor = .altPrimary self.sideloadingProgressView.progress = 0 - #if !BETA - self.navigationItem.leftBarButtonItem = nil - #endif - if let navigationBar = self.navigationController?.navigationBar { navigationBar.addSubview(self.sideloadingProgressView) @@ -109,6 +115,10 @@ class MyAppsViewController: UICollectionViewController super.viewWillAppear(animated) self.updateDataSource() + + #if BETA + self.fetchAppIDs() + #endif } override func prepare(for segue: UIStoryboardSegue, sender: Any?) @@ -138,6 +148,10 @@ class MyAppsViewController: UICollectionViewController let installedApp = self.dataSource.item(at: indexPath) return !installedApp.isSideloaded } + + @IBAction func unwindToMyAppsViewController(_ segue: UIStoryboardSegue) + { + } } private extension MyAppsViewController @@ -156,9 +170,13 @@ private extension MyAppsViewController dynamicDataSource.numberOfItemsHandler = { _ in self.updatesDataSource.itemCount == 0 ? 1 : 0 } dynamicDataSource.cellIdentifierHandler = { _ in "NoUpdatesCell" } dynamicDataSource.cellConfigurationHandler = { (cell, _, indexPath) in - cell.layer.cornerRadius = 20 - cell.layer.masksToBounds = true - cell.contentView.backgroundColor = UIColor.altPrimary.withAlphaComponent(0.15) + let cell = cell as! NoUpdatesCollectionViewCell + cell.layoutMargins.left = self.view.layoutMargins.left + cell.layoutMargins.right = self.view.layoutMargins.right + + cell.blurView.layer.cornerRadius = 20 + cell.blurView.layer.masksToBounds = true + cell.blurView.backgroundColor = .altPrimary } return dynamicDataSource @@ -179,15 +197,19 @@ private extension MyAppsViewController guard let app = installedApp.storeApp else { return } let cell = cell as! UpdateCollectionViewCell - cell.tintColor = app.tintColor ?? .altPrimary - cell.nameLabel.text = app.name - cell.versionDescriptionTextView.text = app.versionDescription - cell.appIconImageView.image = nil - cell.appIconImageView.isIndicatingActivity = true - cell.betaBadgeView.isHidden = !app.isBeta + cell.layoutMargins.left = self.view.layoutMargins.left + cell.layoutMargins.right = self.view.layoutMargins.right - cell.updateButton.isIndicatingActivity = false - cell.updateButton.addTarget(self, action: #selector(MyAppsViewController.updateApp(_:)), for: .primaryActionTriggered) + cell.tintColor = app.tintColor ?? .altPrimary + cell.versionDescriptionTextView.text = app.versionDescription + + cell.bannerView.titleLabel.text = app.name + cell.bannerView.iconImageView.image = nil + cell.bannerView.iconImageView.isIndicatingActivity = true + cell.bannerView.betaBadgeView.isHidden = !app.isBeta + + cell.bannerView.button.isIndicatingActivity = false + cell.bannerView.button.addTarget(self, action: #selector(MyAppsViewController.updateApp(_:)), for: .primaryActionTriggered) if self.expandedAppUpdates.contains(app.bundleIdentifier) { @@ -201,9 +223,9 @@ private extension MyAppsViewController cell.versionDescriptionTextView.moreButton.addTarget(self, action: #selector(MyAppsViewController.toggleUpdateCellMode(_:)), for: .primaryActionTriggered) let progress = AppManager.shared.installationProgress(for: app) - cell.updateButton.progress = progress + cell.bannerView.button.progress = progress - cell.dateLabel.text = Date().relativeDateString(since: app.versionDate, dateFormatter: self.dateFormatter) + cell.bannerView.subtitleLabel.text = Date().relativeDateString(since: app.versionDate, dateFormatter: self.dateFormatter) cell.setNeedsLayout() } @@ -227,8 +249,8 @@ private extension MyAppsViewController } dataSource.prefetchCompletionHandler = { (cell, image, indexPath, error) in let cell = cell as! UpdateCollectionViewCell - cell.appIconImageView.isIndicatingActivity = false - cell.appIconImageView.image = image + cell.bannerView.iconImageView.isIndicatingActivity = false + cell.bannerView.iconImageView.image = image if let error = error { @@ -254,12 +276,15 @@ private extension MyAppsViewController let tintColor = installedApp.storeApp?.tintColor ?? .altPrimary let cell = cell as! InstalledAppCollectionViewCell + cell.layoutMargins.left = self.view.layoutMargins.left + cell.layoutMargins.right = self.view.layoutMargins.right cell.tintColor = tintColor - cell.appIconImageView.isIndicatingActivity = true - cell.betaBadgeView.isHidden = !(installedApp.storeApp?.isBeta ?? false) - cell.refreshButton.isIndicatingActivity = false - cell.refreshButton.addTarget(self, action: #selector(MyAppsViewController.refreshApp(_:)), for: .primaryActionTriggered) + cell.bannerView.iconImageView.isIndicatingActivity = true + cell.bannerView.betaBadgeView.isHidden = !(installedApp.storeApp?.isBeta ?? false) + + cell.bannerView.button.isIndicatingActivity = false + cell.bannerView.button.addTarget(self, action: #selector(MyAppsViewController.refreshApp(_:)), for: .primaryActionTriggered) let currentDate = Date() @@ -267,34 +292,34 @@ private extension MyAppsViewController if numberOfDays == 1 { - cell.refreshButton.setTitle(NSLocalizedString("1 DAY", comment: ""), for: .normal) + cell.bannerView.button.setTitle(NSLocalizedString("1 DAY", comment: ""), for: .normal) } else { - cell.refreshButton.setTitle(String(format: NSLocalizedString("%@ DAYS", comment: ""), NSNumber(value: numberOfDays)), for: .normal) + cell.bannerView.button.setTitle(String(format: NSLocalizedString("%@ DAYS", comment: ""), NSNumber(value: numberOfDays)), for: .normal) } - cell.nameLabel.text = installedApp.name - cell.developerLabel.text = installedApp.storeApp?.developerName ?? NSLocalizedString("Sideloaded", comment: "") + cell.bannerView.titleLabel.text = installedApp.name + cell.bannerView.subtitleLabel.text = installedApp.storeApp?.developerName ?? NSLocalizedString("Sideloaded", comment: "") // Make sure refresh button is correct size. cell.layoutIfNeeded() switch numberOfDays { - case 2...3: cell.refreshButton.tintColor = .refreshOrange - case 4...5: cell.refreshButton.tintColor = .refreshYellow - case 6...: cell.refreshButton.tintColor = .refreshGreen - default: cell.refreshButton.tintColor = .refreshRed + case 2...3: cell.bannerView.button.tintColor = .refreshOrange + case 4...5: cell.bannerView.button.tintColor = .refreshYellow + case 6...: cell.bannerView.button.tintColor = .refreshGreen + default: cell.bannerView.button.tintColor = .refreshRed } if let refreshGroup = self.refreshGroup, let progress = refreshGroup.progress(for: installedApp), progress.fractionCompleted < 1.0 { - cell.refreshButton.progress = progress + cell.bannerView.button.progress = progress } else { - cell.refreshButton.progress = nil + cell.bannerView.button.progress = nil } } dataSource.prefetchHandler = { (item, indexPath, completion) in @@ -312,8 +337,8 @@ private extension MyAppsViewController } dataSource.prefetchCompletionHandler = { (cell, image, indexPath, error) in let cell = cell as! InstalledAppCollectionViewCell - cell.appIconImageView.image = image - cell.appIconImageView.isIndicatingActivity = false + cell.bannerView.iconImageView.image = image + cell.bannerView.iconImageView.isIndicatingActivity = false } return dataSource @@ -358,6 +383,21 @@ private extension MyAppsViewController } } + func fetchAppIDs() + { + AppManager.shared.fetchAppIDs { (result) in + do + { + let (_, context) = try result.get() + try context.save() + } + catch + { + print("Failed to fetch App IDs.", error) + } + } + } + func refresh(_ installedApps: [InstalledApp], completionHandler: @escaping (Result<[String : Result], Error>) -> Void) { func refresh() @@ -368,9 +408,8 @@ private extension MyAppsViewController switch result { case .failure(let error): - let toastView = ToastView(text: error.localizedDescription, detailText: nil) - toastView.setNeedsLayout() - toastView.show(in: self.navigationController?.view ?? self.view, duration: 2.0) + let toastView = ToastView(error: error) + toastView.show(in: self) case .success(let results): let failures = results.compactMapValues { (result) -> Error? in @@ -384,22 +423,32 @@ private extension MyAppsViewController guard !failures.isEmpty else { break } - let localizedText: String - let detailText: String? + let toastView: ToastView - if let failure = failures.first, failures.count == 1 + if let failure = failures.first, results.count == 1 { - localizedText = failure.value.localizedDescription - detailText = nil + toastView = ToastView(error: failure.value) } else { - localizedText = String(format: NSLocalizedString("Failed to refresh %@ apps.", comment: ""), NSNumber(value: failures.count)) - detailText = failures.first?.value.localizedDescription + let localizedText: String + + if failures.count == 1 + { + localizedText = NSLocalizedString("Failed to refresh 1 app.", comment: "") + } + else + { + localizedText = String(format: NSLocalizedString("Failed to refresh %@ apps.", comment: ""), NSNumber(value: failures.count)) + } + + let detailText = failures.first?.value.localizedDescription + + toastView = ToastView(text: localizedText, detailText: detailText) + toastView.preferredDuration = 2.0 } - let toastView = ToastView(text: localizedText, detailText: detailText) - toastView.show(in: self.navigationController?.view ?? self.view, duration: 2.0) + toastView.show(in: self) } self.refreshGroup = nil @@ -559,8 +608,8 @@ private extension MyAppsViewController self.collectionView.reloadItems(at: [indexPath]) case .failure(let error): - let toastView = ToastView(text: error.localizedDescription, detailText: nil) - toastView.show(in: self.navigationController?.view ?? self.view, duration: 2) + let toastView = ToastView(error: error) + toastView.show(in: self) self.collectionView.reloadItems(at: [indexPath]) @@ -591,7 +640,7 @@ private extension MyAppsViewController func presentSideloadingAlert(completion: @escaping (Bool) -> Void) { - let alertController = UIAlertController(title: NSLocalizedString("Sideload Apps (Beta)", comment: ""), message: NSLocalizedString("You may only install 10 apps + app extensions per week due to Apple's restrictions.\n\nIf you encounter an app that is not able to be sideloaded, please report the app to support@altstore.io.", comment: ""), preferredStyle: .alert) + let alertController = UIAlertController(title: NSLocalizedString("Sideload Apps (Beta)", comment: ""), message: NSLocalizedString("If you encounter an app that is not able to be sideloaded, please report the app to support@altstore.io.", comment: ""), preferredStyle: .alert) alertController.addAction(UIAlertAction(title: RSTSystemLocalizedString("OK"), style: .default, handler: { (action) in completion(true) })) @@ -601,7 +650,7 @@ private extension MyAppsViewController self.present(alertController, animated: true, completion: nil) } - func installApp(at fileURL: URL, completion: @escaping (Result) -> Void) + func sideloadApp(at fileURL: URL, completion: @escaping (Result) -> Void) { self.navigationItem.leftBarButtonItem?.isIndicatingActivity = true @@ -614,7 +663,11 @@ private extension MyAppsViewController let unzippedApplicationURL = try FileManager.default.unzipAppBundle(at: fileURL, toDirectory: temporaryDirectory) - guard let application = ALTApplication(fileURL: unzippedApplicationURL) else { return } + guard let application = ALTApplication(fileURL: unzippedApplicationURL) else { throw OperationError.invalidApp } + + #if !BETA + guard AppManager.whitelistedSideloadingBundleIDs.contains(application.bundleIdentifier) else { throw OperationError.sideloadingAppNotSupported(application) } + #endif self.sideloadingProgress = AppManager.shared.install(application, presentingViewController: self) { (result) in try? FileManager.default.removeItem(at: temporaryDirectory) @@ -622,8 +675,8 @@ private extension MyAppsViewController DispatchQueue.main.async { if let error = result.error { - let toastView = ToastView(text: error.localizedDescription, detailText: nil) - toastView.show(in: self.view, duration: 2.0) + let toastView = ToastView(error: error) + toastView.show(in: self) } else { @@ -648,7 +701,31 @@ private extension MyAppsViewController { try? FileManager.default.removeItem(at: temporaryDirectory) - self.navigationItem.leftBarButtonItem?.isIndicatingActivity = false + DispatchQueue.main.async { + self.navigationItem.leftBarButtonItem?.isIndicatingActivity = false + + if let localizedError = error as? OperationError, case OperationError.sideloadingAppNotSupported = localizedError + { + let message = NSLocalizedString(""" + Sideloading apps is in beta, and is currently limited to a small number of apps. This restriction is temporary, and you will be able to sideload any app once the feature is finished. + + In the meantime, you can help us beta test sideloading apps by becoming a Patron. + """, comment: "") + + let alertController = UIAlertController(title: localizedError.localizedDescription, message: message, preferredStyle: .alert) + alertController.addAction(.cancel) + alertController.addAction(UIAlertAction(title: NSLocalizedString("Become a Patron", comment: ""), style: .default, handler: { (action) in + NotificationCenter.default.post(name: AppDelegate.openPatreonSettingsDeepLinkNotification, object: nil) + })) + + self.present(alertController, animated: true, completion: nil) + } + else + { + let toastView = ToastView(error: error) + toastView.show(in: self) + } + } completion(.failure(error)) } @@ -700,14 +777,22 @@ private extension MyAppsViewController else { return } let installedApp = self.dataSource.item(at: indexPath) - guard installedApp.storeApp == nil else { return } + #if DEBUG self.presentAlert(for: installedApp) + #else + if (UserDefaults.standard.legacySideloadedApps ?? []).contains(installedApp.bundleIdentifier) + { + // Only display alert for legacy sideloaded apps. + self.presentAlert(for: installedApp) + } + #endif } @objc func importApp(_ notification: Notification) { - #if BETA + // Make sure left UIBarButtonItem has been set. + self.loadViewIfNeeded() guard let fileURL = notification.userInfo?[AppDelegate.importAppDeepLinkURLKey] as? URL else { return } guard self.presentedViewController == nil else { return } @@ -724,10 +809,12 @@ private extension MyAppsViewController } } + #if BETA + self.presentSideloadingAlert { (shouldContinue) in if shouldContinue { - self.installApp(at: fileURL) { (result) in + self.sideloadApp(at: fileURL) { (result) in finish() } } @@ -737,6 +824,12 @@ private extension MyAppsViewController } } + #else + + self.sideloadApp(at: fileURL) { (result) in + finish() + } + #endif } } @@ -776,7 +869,7 @@ extension MyAppsViewController return headerView - case .installedApps: + case .installedApps where kind == UICollectionView.elementKindSectionHeader: let headerView = collectionView.dequeueReusableSupplementaryView(ofKind: UICollectionView.elementKindSectionHeader, withReuseIdentifier: "InstalledAppsHeader", for: indexPath) as! InstalledAppsCollectionHeaderView UIView.performWithoutAnimation { @@ -792,6 +885,35 @@ extension MyAppsViewController } return headerView + + case .installedApps: + let footerView = collectionView.dequeueReusableSupplementaryView(ofKind: UICollectionView.elementKindSectionFooter, withReuseIdentifier: "InstalledAppsFooter", for: indexPath) as! InstalledAppsCollectionFooterView + + guard let team = DatabaseManager.shared.activeTeam() else { return footerView } + switch team.type + { + case .free: + let registeredAppIDs = team.appIDs.count + + let maximumAppIDCount = 10 + let remainingAppIDs = max(maximumAppIDCount - registeredAppIDs, 0) + + if remainingAppIDs == 1 + { + footerView.textLabel.text = String(format: NSLocalizedString("1 App ID Remaining", comment: "")) + } + else + { + footerView.textLabel.text = String(format: NSLocalizedString("%@ App IDs Remaining", comment: ""), NSNumber(value: remainingAppIDs)) + } + + footerView.textLabel.isHidden = false + + case .individual, .organization, .unknown: footerView.textLabel.isHidden = true + @unknown default: break + } + + return footerView } } @@ -813,14 +935,11 @@ extension MyAppsViewController: UICollectionViewDelegateFlowLayout { func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAt indexPath: IndexPath) -> CGSize { - let padding = 30 as CGFloat - let width = collectionView.bounds.width - padding - let section = Section.allCases[indexPath.section] switch section { case .noUpdates: - let size = CGSize(width: width, height: 44) + let size = CGSize(width: collectionView.bounds.width, height: 44) return size case .updates: @@ -831,7 +950,10 @@ extension MyAppsViewController: UICollectionViewDelegateFlowLayout return previousHeight } - let widthConstraint = self.prototypeUpdateCell.contentView.widthAnchor.constraint(equalToConstant: width) + // Manually change cell's width to prevent conflicting with UIView-Encapsulated-Layout-Width constraints. + self.prototypeUpdateCell.frame.size.width = collectionView.bounds.width + + let widthConstraint = self.prototypeUpdateCell.contentView.widthAnchor.constraint(equalToConstant: collectionView.bounds.width) NSLayoutConstraint.activate([widthConstraint]) defer { NSLayoutConstraint.deactivate([widthConstraint]) } @@ -842,7 +964,7 @@ extension MyAppsViewController: UICollectionViewDelegateFlowLayout return size case .installedApps: - return CGSize(width: collectionView.bounds.width, height: 60) + return CGSize(width: collectionView.bounds.width, height: 88) } } @@ -860,20 +982,38 @@ extension MyAppsViewController: UICollectionViewDelegateFlowLayout } } - func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, insetForSectionAt section: Int) -> UIEdgeInsets + func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, referenceSizeForFooterInSection section: Int) -> CGSize { let section = Section.allCases[section] switch section { - case .noUpdates: - guard self.updatesDataSource.itemCount == 0 else { return .zero } - return UIEdgeInsets(top: 12, left: 15, bottom: 20, right: 15) + case .noUpdates: return .zero + case .updates: return .zero + case .installedApps: + #if BETA + guard let _ = DatabaseManager.shared.activeTeam() else { return .zero } - case .updates: - guard self.updatesDataSource.itemCount > 0 else { return .zero } - return UIEdgeInsets(top: 12, left: 15, bottom: 20, right: 15) - - case .installedApps: return UIEdgeInsets(top: 12, left: 0, bottom: 20, right: 0) + let indexPath = IndexPath(row: 0, section: section.rawValue) + let footerView = self.collectionView(collectionView, viewForSupplementaryElementOfKind: UICollectionView.elementKindSectionFooter, at: indexPath) as! InstalledAppsCollectionFooterView + + let size = footerView.systemLayoutSizeFitting(CGSize(width: collectionView.frame.width, height: UIView.layoutFittingExpandedSize.height), + withHorizontalFittingPriority: .required, + verticalFittingPriority: .fittingSizeLevel) + return size + #else + return .zero + #endif + } + } + + func collectionView(_ myCV: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, insetForSectionAt section: Int) -> UIEdgeInsets + { + let section = Section.allCases[section] + switch section + { + case .noUpdates where self.updatesDataSource.itemCount != 0: return .zero + case .updates where self.updatesDataSource.itemCount == 0: return .zero + default: return UIEdgeInsets(top: 12, left: 0, bottom: 20, right: 0) } } } @@ -930,7 +1070,7 @@ extension MyAppsViewController: UIDocumentPickerDelegate { guard let fileURL = urls.first else { return } - self.installApp(at: fileURL) { (result) in + self.sideloadApp(at: fileURL) { (result) in print("Sideloaded app at \(fileURL) with result:", result) } } diff --git a/AltStore/My Apps/UpdateCollectionViewCell.swift b/AltStore/My Apps/UpdateCollectionViewCell.swift index 04cff8e0..beecafdd 100644 --- a/AltStore/My Apps/UpdateCollectionViewCell.swift +++ b/AltStore/My Apps/UpdateCollectionViewCell.swift @@ -25,20 +25,27 @@ extension UpdateCollectionViewCell } } - @IBOutlet var appIconImageView: UIImageView! - @IBOutlet var nameLabel: UILabel! - @IBOutlet var dateLabel: UILabel! - @IBOutlet var updateButton: PillButton! + @IBOutlet var bannerView: AppBannerView! @IBOutlet var versionDescriptionTitleLabel: UILabel! @IBOutlet var versionDescriptionTextView: CollapsingTextView! - @IBOutlet var betaBadgeView: UIImageView! + + @IBOutlet private var blurView: UIVisualEffectView! + + private var originalTintColor: UIColor? override func awakeFromNib() { super.awakeFromNib() - self.contentView.layer.cornerRadius = 20 - self.contentView.layer.masksToBounds = true + // Prevent temporary unsatisfiable constraint errors due to UIView-Encapsulated-Layout constraints. + self.contentView.autoresizingMask = [.flexibleWidth, .flexibleHeight] + self.contentView.preservesSuperviewLayoutMargins = true + + self.bannerView.backgroundEffectView.isHidden = true + self.bannerView.button.setTitle(NSLocalizedString("UPDATE", comment: ""), for: .normal) + + self.blurView.layer.cornerRadius = 20 + self.blurView.layer.masksToBounds = true self.update() } @@ -47,6 +54,11 @@ extension UpdateCollectionViewCell { super.tintColorDidChange() + if self.tintAdjustmentMode != .dimmed + { + self.originalTintColor = self.tintColor + } + self.update() } @@ -86,12 +98,9 @@ private extension UpdateCollectionViewCell case .expanded: self.versionDescriptionTextView.isCollapsed = false } - self.versionDescriptionTitleLabel.textColor = self.tintColor - self.contentView.backgroundColor = self.tintColor.withAlphaComponent(0.1) - - self.updateButton.setTitleColor(self.tintColor, for: .normal) - self.updateButton.backgroundColor = self.tintColor.withAlphaComponent(0.15) - self.updateButton.progressTintColor = self.tintColor + self.versionDescriptionTitleLabel.textColor = self.originalTintColor ?? self.tintColor + self.blurView.backgroundColor = self.originalTintColor ?? self.tintColor + self.bannerView.button.progressTintColor = self.originalTintColor ?? self.tintColor self.setNeedsLayout() self.layoutIfNeeded() diff --git a/AltStore/My Apps/UpdateCollectionViewCell.xib b/AltStore/My Apps/UpdateCollectionViewCell.xib index 4b928242..73a2f158 100644 --- a/AltStore/My Apps/UpdateCollectionViewCell.xib +++ b/AltStore/My Apps/UpdateCollectionViewCell.xib @@ -1,130 +1,112 @@ - - - - + + - - + + - - + + - + - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - + + + + - - - - + + - - - - - - + + @@ -132,6 +114,8 @@ - + + + diff --git a/AltStore/News/NewsCollectionViewCell.swift b/AltStore/News/NewsCollectionViewCell.swift index adf9ba18..d9c4b276 100644 --- a/AltStore/News/NewsCollectionViewCell.swift +++ b/AltStore/News/NewsCollectionViewCell.swift @@ -13,13 +13,16 @@ class NewsCollectionViewCell: UICollectionViewCell @IBOutlet var titleLabel: UILabel! @IBOutlet var captionLabel: UILabel! @IBOutlet var imageView: UIImageView! + @IBOutlet var contentBackgroundView: UIView! override func awakeFromNib() { super.awakeFromNib() - self.contentView.layer.cornerRadius = 30 - self.contentView.clipsToBounds = true + self.contentView.preservesSuperviewLayoutMargins = true + + self.contentBackgroundView.layer.cornerRadius = 30 + self.contentBackgroundView.clipsToBounds = true self.imageView.layer.cornerRadius = 30 self.imageView.clipsToBounds = true diff --git a/AltStore/News/NewsCollectionViewCell.xib b/AltStore/News/NewsCollectionViewCell.xib index 0b29532b..42ec35d6 100644 --- a/AltStore/News/NewsCollectionViewCell.xib +++ b/AltStore/News/NewsCollectionViewCell.xib @@ -1,11 +1,9 @@ - - - - + + - + @@ -18,23 +16,26 @@ - - + + + + + - + - + - - + - + @@ -63,15 +64,21 @@ - - + + + + + + + + diff --git a/AltStore/News/NewsViewController.swift b/AltStore/News/NewsViewController.swift index 9e0ca0a3..dfa73fcc 100644 --- a/AltStore/News/NewsViewController.swift +++ b/AltStore/News/NewsViewController.swift @@ -22,8 +22,17 @@ private class AppBannerFooterView: UICollectionReusableView { super.init(frame: frame) - self.addSubview(self.bannerView, pinningEdgesWith: UIEdgeInsets(top: 0, left: 20, bottom: 0, right: 20)) self.addGestureRecognizer(self.tapGestureRecognizer) + + self.bannerView.translatesAutoresizingMaskIntoConstraints = false + self.addSubview(self.bannerView) + + NSLayoutConstraint.activate([ + self.bannerView.topAnchor.constraint(equalTo: self.topAnchor), + self.bannerView.bottomAnchor.constraint(equalTo: self.bottomAnchor), + self.bannerView.leadingAnchor.constraint(equalTo: self.layoutMarginsGuide.leadingAnchor), + self.bannerView.trailingAnchor.constraint(equalTo: self.layoutMarginsGuide.trailingAnchor) + ]) } required init?(coder aDecoder: NSCoder) { @@ -52,7 +61,6 @@ class NewsViewController: UICollectionViewController super.viewDidLoad() self.prototypeCell = NewsCollectionViewCell.instantiate(with: NewsCollectionViewCell.nib!) - self.prototypeCell.translatesAutoresizingMaskIntoConstraints = false self.prototypeCell.contentView.translatesAutoresizingMaskIntoConstraints = false self.collectionView.dataSource = self.dataSource @@ -93,15 +101,18 @@ private extension NewsViewController let fetchRequest = NewsItem.fetchRequest() as NSFetchRequest fetchRequest.sortDescriptors = [NSSortDescriptor(keyPath: \NewsItem.sortIndex, ascending: false)] - let fetchedResultsController = NSFetchedResultsController(fetchRequest: fetchRequest, managedObjectContext: DatabaseManager.shared.viewContext, sectionNameKeyPath: #keyPath(NewsItem.date), cacheName: nil) + let fetchedResultsController = NSFetchedResultsController(fetchRequest: fetchRequest, managedObjectContext: DatabaseManager.shared.viewContext, sectionNameKeyPath: #keyPath(NewsItem.sortIndex), cacheName: nil) let dataSource = RSTFetchedResultsCollectionViewPrefetchingDataSource(fetchedResultsController: fetchedResultsController) dataSource.proxy = self dataSource.cellConfigurationHandler = { (cell, newsItem, indexPath) in let cell = cell as! NewsCollectionViewCell + cell.layoutMargins.left = self.view.layoutMargins.left + cell.layoutMargins.right = self.view.layoutMargins.right + cell.titleLabel.text = newsItem.title cell.captionLabel.text = newsItem.caption - cell.contentView.backgroundColor = newsItem.tintColor + cell.contentBackgroundView.backgroundColor = newsItem.tintColor cell.imageView.image = nil @@ -315,6 +326,9 @@ extension NewsViewController let footerView = collectionView.dequeueReusableSupplementaryView(ofKind: UICollectionView.elementKindSectionFooter, withReuseIdentifier: "AppBanner", for: indexPath) as! AppBannerFooterView guard let storeApp = item.storeApp else { return footerView } + footerView.layoutMargins.left = self.view.layoutMargins.left + footerView.layoutMargins.right = self.view.layoutMargins.right + footerView.bannerView.titleLabel.text = storeApp.name footerView.bannerView.subtitleLabel.text = storeApp.developerName footerView.bannerView.tintColor = storeApp.tintColor @@ -330,7 +344,6 @@ extension NewsViewController let progress = AppManager.shared.installationProgress(for: storeApp) footerView.bannerView.button.progress = progress - footerView.bannerView.button.isInverted = false if Date() < storeApp.versionDate { @@ -345,7 +358,6 @@ extension NewsViewController { footerView.bannerView.button.setTitle(NSLocalizedString("OPEN", comment: ""), for: .normal) footerView.bannerView.button.progress = nil - footerView.bannerView.button.isInverted = true footerView.bannerView.button.countdownDate = nil } @@ -358,10 +370,7 @@ extension NewsViewController extension NewsViewController: UICollectionViewDelegateFlowLayout { func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAt indexPath: IndexPath) -> CGSize - { - let padding = 40 as CGFloat - let width = collectionView.bounds.width - padding - + { let item = self.dataSource.item(at: indexPath) if let previousSize = self.cachedCellSizes[item.identifier] @@ -369,7 +378,7 @@ extension NewsViewController: UICollectionViewDelegateFlowLayout return previousSize } - let widthConstraint = self.prototypeCell.contentView.widthAnchor.constraint(equalToConstant: width) + let widthConstraint = self.prototypeCell.contentView.widthAnchor.constraint(equalToConstant: collectionView.bounds.width) NSLayoutConstraint.activate([widthConstraint]) defer { NSLayoutConstraint.deactivate([widthConstraint]) } @@ -396,7 +405,7 @@ extension NewsViewController: UICollectionViewDelegateFlowLayout func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, insetForSectionAt section: Int) -> UIEdgeInsets { - var insets = UIEdgeInsets(top: 30, left: 20, bottom: 13, right: 20) + var insets = UIEdgeInsets(top: 30, left: 0, bottom: 13, right: 0) if section == 0 { diff --git a/AltStore/Operations/AppOperationContext.swift b/AltStore/Operations/AppOperationContext.swift index a673a296..5087655c 100644 --- a/AltStore/Operations/AppOperationContext.swift +++ b/AltStore/Operations/AppOperationContext.swift @@ -29,7 +29,7 @@ class AppOperationContext var app: ALTApplication? var resignedApp: ALTApplication? - var connection: NWConnection? + var installationConnection: ServerConnection? var installedApp: InstalledApp? { didSet { diff --git a/AltStore/Operations/AuthenticationOperation.swift b/AltStore/Operations/AuthenticationOperation.swift index 7dcf7897..f5bbb4fa 100644 --- a/AltStore/Operations/AuthenticationOperation.swift +++ b/AltStore/Operations/AuthenticationOperation.swift @@ -8,7 +8,9 @@ import Foundation import Roxas +import Network +import AltKit import AltSign enum AuthenticationError: LocalizedError @@ -30,13 +32,18 @@ enum AuthenticationError: LocalizedError } @objc(AuthenticationOperation) -class AuthenticationOperation: ResultOperation +class AuthenticationOperation: ResultOperation<(ALTSigner, ALTAppleAPISession)> { + let group: OperationGroup + private weak var presentingViewController: UIViewController? private lazy var navigationController: UINavigationController = { let navigationController = self.storyboard.instantiateViewController(withIdentifier: "navigationController") as! UINavigationController - navigationController.presentationController?.delegate = self + if #available(iOS 13.0, *) + { + navigationController.isModalInPresentation = true + } return navigationController }() @@ -45,14 +52,18 @@ class AuthenticationOperation: ResultOperation private var appleIDPassword: String? private var shouldShowInstructions = false - private var signer: ALTSigner? + private let operationQueue = OperationQueue() - init(presentingViewController: UIViewController?) + private var submitCodeAction: UIAlertAction? + + init(group: OperationGroup, presentingViewController: UIViewController?) { + self.group = group self.presentingViewController = presentingViewController super.init() + self.operationQueue.name = "com.altstore.AuthenticationOperation" self.progress.totalUnitCount = 3 } @@ -60,18 +71,24 @@ class AuthenticationOperation: ResultOperation { super.main() + if let error = self.group.error + { + self.finish(.failure(error)) + return + } + // Sign In - self.signIn { (result) in + self.signIn() { (result) in guard !self.isCancelled else { return self.finish(.failure(OperationError.cancelled)) } switch result { case .failure(let error): self.finish(.failure(error)) - case .success(let account): + case .success(let account, let session): self.progress.completedUnitCount += 1 // Fetch Team - self.fetchTeam(for: account) { (result) in + self.fetchTeam(for: account, session: session) { (result) in guard !self.isCancelled else { return self.finish(.failure(OperationError.cancelled)) } switch result @@ -81,7 +98,7 @@ class AuthenticationOperation: ResultOperation self.progress.completedUnitCount += 1 // Fetch Certificate - self.fetchCertificate(for: team) { (result) in + self.fetchCertificate(for: team, session: session) { (result) in guard !self.isCancelled else { return self.finish(.failure(OperationError.cancelled)) } switch result @@ -89,13 +106,24 @@ class AuthenticationOperation: ResultOperation case .failure(let error): self.finish(.failure(error)) case .success(let certificate): self.progress.completedUnitCount += 1 - - let signer = ALTSigner(team: team, certificate: certificate) - self.signer = signer - - self.showInstructionsIfNecessary() { (didShowInstructions) in - self.finish(.success(signer)) - } + + // Save account/team to disk. + self.save(team) { (result) in + guard !self.isCancelled else { return self.finish(.failure(OperationError.cancelled)) } + + switch result + { + case .failure(let error): self.finish(.failure(error)) + case .success: + let signer = ALTSigner(team: team, certificate: certificate) + + // Must cache App IDs _after_ saving account/team to disk. + self.cacheAppIDs(signer: signer, session: session) { (result) in + let result = result.map { _ in (signer, session) } + self.finish(result) + } + } + } } } } @@ -104,21 +132,65 @@ class AuthenticationOperation: ResultOperation } } - override func finish(_ result: Result) + func save(_ altTeam: ALTTeam, completionHandler: @escaping (Result) -> Void) + { + let context = DatabaseManager.shared.persistentContainer.newBackgroundContext() + context.performAndWait { + do + { + let account: Account + let team: Team + + if let tempAccount = Account.first(satisfying: NSPredicate(format: "%K == %@", #keyPath(Account.identifier), altTeam.account.identifier), in: context) + { + account = tempAccount + } + else + { + account = Account(altTeam.account, context: context) + } + + if let tempTeam = Team.first(satisfying: NSPredicate(format: "%K == %@", #keyPath(Team.identifier), altTeam.identifier), in: context) + { + team = tempTeam + } + else + { + team = Team(altTeam, account: account, context: context) + } + + account.update(account: altTeam.account) + team.update(team: altTeam) + + try context.save() + + completionHandler(.success(())) + } + catch + { + completionHandler(.failure(error)) + } + } + } + + override func finish(_ result: Result<(ALTSigner, ALTAppleAPISession), Error>) { guard !self.isFinished else { return } print("Finished authenticating with result:", result) let context = DatabaseManager.shared.persistentContainer.newBackgroundContext() - context.performAndWait { + context.perform { do { - let signer = try result.get() - let altAccount = signer.team.account + let (signer, session) = try result.get() + + guard + let account = Account.first(satisfying: NSPredicate(format: "%K == %@", #keyPath(Account.identifier), signer.team.account.identifier), in: context), + let team = Team.first(satisfying: NSPredicate(format: "%K == %@", #keyPath(Team.identifier), signer.team.identifier), in: context) + else { throw AuthenticationError.noTeam } // Account - let account = Account(altAccount, context: context) account.isActiveAccount = true let otherAccountsFetchRequest = Account.fetchRequest() as NSFetchRequest @@ -131,7 +203,6 @@ class AuthenticationOperation: ResultOperation } // Team - let team = Team(signer.team, account: account, context: context) team.isActiveTeam = true let otherTeamsFetchRequest = Team.fetchRequest() as NSFetchRequest @@ -143,25 +214,41 @@ class AuthenticationOperation: ResultOperation team.isActiveTeam = false } + if let altStoreApp = InstalledApp.fetchAltStore(in: context), altStoreApp.team == nil + { + // No team assigned to AltStore app yet, so assume this team was used to originally install it. + altStoreApp.team = team + } + // Save try context.save() // Update keychain - Keychain.shared.appleIDEmailAddress = altAccount.appleID // "account" may have nil appleID since we just saved. + Keychain.shared.appleIDEmailAddress = signer.team.account.appleID Keychain.shared.appleIDPassword = self.appleIDPassword - Keychain.shared.signingCertificateSerialNumber = signer.certificate.serialNumber - Keychain.shared.signingCertificatePrivateKey = signer.certificate.privateKey + Keychain.shared.signingCertificate = signer.certificate.p12Data() + Keychain.shared.signingCertificatePassword = signer.certificate.machineIdentifier - super.finish(.success(signer)) + self.showInstructionsIfNecessary() { (didShowInstructions) in + + // Refresh screen must go last since a successful refresh will cause the app to quit. + self.showRefreshScreenIfNecessary(signer: signer, session: session) { (didShowRefreshAlert) in + super.finish(result) + + DispatchQueue.main.async { + self.navigationController.dismiss(animated: true, completion: nil) + } + } + } } catch { - super.finish(.failure(error)) - } - - DispatchQueue.main.async { - self.navigationController.dismiss(animated: true, completion: nil) + super.finish(result) + + DispatchQueue.main.async { + self.navigationController.dismiss(animated: true, completion: nil) + } } } } @@ -194,21 +281,26 @@ private extension AuthenticationOperation private extension AuthenticationOperation { - func signIn(completionHandler: @escaping (Result) -> Void) + func signIn(completionHandler: @escaping (Result<(ALTAccount, ALTAppleAPISession), Swift.Error>) -> Void) { func authenticate() { DispatchQueue.main.async { let authenticationViewController = self.storyboard.instantiateViewController(withIdentifier: "authenticationViewController") as! AuthenticationViewController - authenticationViewController.authenticationHandler = { (result) in - if let (account, password) = result + authenticationViewController.authenticationHandler = { (appleID, password, completionHandler) in + self.authenticate(appleID: appleID, password: password) { (result) in + completionHandler(result) + } + } + authenticationViewController.completionHandler = { (result) in + if let (account, session, password) = result { // We presented the Auth UI and the user signed in. // In this case, we'll assume we should show the instructions again. self.shouldShowInstructions = true self.appleIDPassword = password - completionHandler(.success(account)) + completionHandler(.success((account, session))) } else { @@ -225,24 +317,17 @@ private extension AuthenticationOperation if let appleID = Keychain.shared.appleIDEmailAddress, let password = Keychain.shared.appleIDPassword { - ALTAppleAPI.shared.authenticate(appleID: appleID, password: password) { (account, error) in - do + self.authenticate(appleID: appleID, password: password) { (result) in + switch result { + case .success(let account, let session): self.appleIDPassword = password + completionHandler(.success((account, session))) - let account = try Result(account, error).get() - completionHandler(.success(account)) - } - catch ALTAppleAPIError.incorrectCredentials - { + case .failure(ALTAppleAPIError.incorrectCredentials), .failure(ALTAppleAPIError.appSpecificPasswordRequired): authenticate() - } - catch ALTAppleAPIError.appSpecificPasswordRequired - { - authenticate() - } - catch - { + + case .failure(let error): completionHandler(.failure(error)) } } @@ -253,7 +338,78 @@ private extension AuthenticationOperation } } - func fetchTeam(for account: ALTAccount, completionHandler: @escaping (Result) -> Void) + func authenticate(appleID: String, password: String, completionHandler: @escaping (Result<(ALTAccount, ALTAppleAPISession), Swift.Error>) -> Void) + { + let fetchAnisetteDataOperation = FetchAnisetteDataOperation(group: self.group) + fetchAnisetteDataOperation.resultHandler = { (result) in + switch result + { + case .failure(let error): completionHandler(.failure(error)) + case .success(let anisetteData): + let verificationHandler: ((@escaping (String?) -> Void) -> Void)? + + if let presentingViewController = self.presentingViewController + { + verificationHandler = { (completionHandler) in + DispatchQueue.main.async { + let alertController = UIAlertController(title: NSLocalizedString("Please enter the 6-digit verification code that was sent to your Apple devices.", comment: ""), message: nil, preferredStyle: .alert) + alertController.addTextField { (textField) in + textField.autocorrectionType = .no + textField.autocapitalizationType = .none + textField.keyboardType = .numberPad + + NotificationCenter.default.addObserver(self, selector: #selector(AuthenticationOperation.textFieldTextDidChange(_:)), name: UITextField.textDidChangeNotification, object: textField) + } + + let submitAction = UIAlertAction(title: NSLocalizedString("Continue", comment: ""), style: .default) { (action) in + let textField = alertController.textFields?.first + + let code = textField?.text ?? "" + completionHandler(code) + } + submitAction.isEnabled = false + alertController.addAction(submitAction) + self.submitCodeAction = submitAction + + alertController.addAction(UIAlertAction(title: RSTSystemLocalizedString("Cancel"), style: .cancel) { (action) in + completionHandler(nil) + }) + + if self.navigationController.presentingViewController != nil + { + self.navigationController.present(alertController, animated: true, completion: nil) + } + else + { + presentingViewController.present(alertController, animated: true, completion: nil) + } + } + } + } + else + { + // No view controller to present security code alert, so don't provide verificationHandler. + verificationHandler = nil + } + + ALTAppleAPI.shared.authenticate(appleID: appleID, password: password, anisetteData: anisetteData, + verificationHandler: verificationHandler) { (account, session, error) in + if let account = account, let session = session + { + completionHandler(.success((account, session))) + } + else + { + completionHandler(.failure(error ?? OperationError.unknown)) + } + } + } + } + + self.operationQueue.addOperation(fetchAnisetteDataOperation) + } + + func fetchTeam(for account: ALTAccount, session: ALTAppleAPISession, completionHandler: @escaping (Result) -> Void) { func selectTeam(from teams: [ALTTeam]) { @@ -275,7 +431,7 @@ private extension AuthenticationOperation } } - ALTAppleAPI.shared.fetchTeams(for: account) { (teams, error) in + ALTAppleAPI.shared.fetchTeams(for: account, session: session) { (teams, error) in switch Result(teams, error) { case .failure(let error): completionHandler(.failure(error)) @@ -294,18 +450,18 @@ private extension AuthenticationOperation } } - func fetchCertificate(for team: ALTTeam, completionHandler: @escaping (Result) -> Void) + func fetchCertificate(for team: ALTTeam, session: ALTAppleAPISession, completionHandler: @escaping (Result) -> Void) { func requestCertificate() { let machineName = "AltStore - " + UIDevice.current.name - ALTAppleAPI.shared.addCertificate(machineName: machineName, to: team) { (certificate, error) in + ALTAppleAPI.shared.addCertificate(machineName: machineName, to: team, session: session) { (certificate, error) in do { let certificate = try Result(certificate, error).get() guard let privateKey = certificate.privateKey else { throw AuthenticationError.missingPrivateKey } - ALTAppleAPI.shared.fetchCertificates(for: team) { (certificates, error) in + ALTAppleAPI.shared.fetchCertificates(for: team, session: session) { (certificates, error) in do { let certificates = try Result(certificates, error).get() @@ -334,7 +490,7 @@ private extension AuthenticationOperation { guard let certificate = certificates.first else { return completionHandler(.failure(AuthenticationError.noCertificate)) } - ALTAppleAPI.shared.revoke(certificate, for: team) { (success, error) in + ALTAppleAPI.shared.revoke(certificate, for: team, session: session) { (success, error) in if let error = error, !success { completionHandler(.failure(error)) @@ -346,25 +502,51 @@ private extension AuthenticationOperation } } - ALTAppleAPI.shared.fetchCertificates(for: team) { (certificates, error) in + ALTAppleAPI.shared.fetchCertificates(for: team, session: session) { (certificates, error) in do { let certificates = try Result(certificates, error).get() if + let data = Keychain.shared.signingCertificate, + let localCertificate = ALTCertificate(p12Data: data, password: nil), + let certificate = certificates.first(where: { $0.serialNumber == localCertificate.serialNumber }) + { + // We have a certificate stored in the keychain and it hasn't been revoked. + localCertificate.machineIdentifier = certificate.machineIdentifier + completionHandler(.success(localCertificate)) + } + else if let serialNumber = Keychain.shared.signingCertificateSerialNumber, let privateKey = Keychain.shared.signingCertificatePrivateKey, let certificate = certificates.first(where: { $0.serialNumber == serialNumber }) { + // LEGACY + // We have the private key for one of the certificates, so add it to certificate and use it. certificate.privateKey = privateKey completionHandler(.success(certificate)) } + else if + let serialNumber = Bundle.main.object(forInfoDictionaryKey: Bundle.Info.certificateID) as? String, + let certificate = certificates.first(where: { $0.serialNumber == serialNumber }), + let machineIdentifier = certificate.machineIdentifier, + FileManager.default.fileExists(atPath: Bundle.main.certificateURL.path), + let data = try? Data(contentsOf: Bundle.main.certificateURL), + let localCertificate = ALTCertificate(p12Data: data, password: machineIdentifier) + { + // We have an embedded certificate that hasn't been revoked. + localCertificate.machineIdentifier = machineIdentifier + completionHandler(.success(localCertificate)) + } else if certificates.isEmpty { + // No certificates, so request a new one. requestCertificate() } else { + // We don't have private keys for any of the certificates, + // so we need to revoke one and create a new one. replaceCertificate(from: certificates) } } @@ -375,6 +557,30 @@ private extension AuthenticationOperation } } + func cacheAppIDs(signer: ALTSigner, session: ALTAppleAPISession, completionHandler: @escaping (Result) -> Void) + { + let group = OperationGroup() + group.signer = signer + group.session = session + + let fetchAppIDsOperation = FetchAppIDsOperation(group: group) + fetchAppIDsOperation.resultHandler = { (result) in + do + { + let (_, context) = try result.get() + try context.save() + + completionHandler(.success(())) + } + catch + { + completionHandler(.failure(error)) + } + } + + self.operationQueue.addOperation(fetchAppIDsOperation) + } + func showInstructionsIfNecessary(completionHandler: @escaping (Bool) -> Void) { guard self.shouldShowInstructions else { return completionHandler(false) } @@ -392,19 +598,40 @@ private extension AuthenticationOperation } } } -} - -extension AuthenticationOperation: UIAdaptivePresentationControllerDelegate -{ - func presentationControllerWillDismiss(_ presentationController: UIPresentationController) + + func showRefreshScreenIfNecessary(signer: ALTSigner, session: ALTAppleAPISession, completionHandler: @escaping (Bool) -> Void) { - if let signer = self.signer - { - self.finish(.success(signer)) - } - else - { - self.finish(.failure(OperationError.cancelled)) + guard let application = ALTApplication(fileURL: Bundle.main.bundleURL), let provisioningProfile = application.provisioningProfile else { return completionHandler(false) } + + // If we're not using the same certificate used to install AltStore, warn user that they need to refresh. + guard !provisioningProfile.certificates.contains(signer.certificate) else { return completionHandler(false) } + +#if DEBUG + completionHandler(false) +#else + DispatchQueue.main.async { + let refreshViewController = self.storyboard.instantiateViewController(withIdentifier: "refreshAltStoreViewController") as! RefreshAltStoreViewController + refreshViewController.signer = signer + refreshViewController.session = session + refreshViewController.completionHandler = { _ in + completionHandler(true) + } + + if !self.present(refreshViewController) + { + completionHandler(false) + } } +#endif + } +} + +extension AuthenticationOperation +{ + @objc func textFieldTextDidChange(_ notification: Notification) + { + guard let textField = notification.object as? UITextField else { return } + + self.submitCodeAction?.isEnabled = (textField.text ?? "").count == 6 } } diff --git a/AltStore/Operations/FetchAnisetteDataOperation.swift b/AltStore/Operations/FetchAnisetteDataOperation.swift new file mode 100644 index 00000000..a6878fbf --- /dev/null +++ b/AltStore/Operations/FetchAnisetteDataOperation.swift @@ -0,0 +1,73 @@ +// +// FetchAnisetteDataOperation.swift +// AltStore +// +// Created by Riley Testut on 1/7/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +import Foundation + +import AltSign +import AltKit + +import Roxas + +@objc(FetchAnisetteDataOperation) +class FetchAnisetteDataOperation: ResultOperation +{ + let group: OperationGroup + + init(group: OperationGroup) + { + self.group = group + + super.init() + } + + override func main() + { + super.main() + + if let error = self.group.error + { + self.finish(.failure(error)) + return + } + + guard let server = self.group.server else { return self.finish(.failure(OperationError.invalidParameters)) } + + ServerManager.shared.connect(to: server) { (result) in + switch result + { + case .failure(let error): + self.finish(.failure(error)) + case .success(let connection): + print("Sending anisette data request...") + + let request = AnisetteDataRequest() + connection.send(request) { (result) in + print("Sent anisette data request!") + + switch result + { + case .failure(let error): self.finish(.failure(error)) + case .success: + print("Waiting for anisette data...") + connection.receiveResponse() { (result) in + print("Receiving anisette data:", result) + + switch result + { + case .failure(let error): self.finish(.failure(error)) + case .success(.error(let response)): self.finish(.failure(response.error)) + case .success(.anisetteData(let response)): self.finish(.success(response.anisetteData)) + case .success: self.finish(.failure(ALTServerError(.unknownRequest))) + } + } + } + } + } + } + } +} diff --git a/AltStore/Operations/FetchAppIDsOperation.swift b/AltStore/Operations/FetchAppIDsOperation.swift new file mode 100644 index 00000000..d6c4099d --- /dev/null +++ b/AltStore/Operations/FetchAppIDsOperation.swift @@ -0,0 +1,73 @@ +// +// FetchAppIDsOperation.swift +// AltStore +// +// Created by Riley Testut on 1/27/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +import Foundation + +import AltSign +import AltKit + +import Roxas + +@objc(FetchAppIDsOperation) +class FetchAppIDsOperation: ResultOperation<([AppID], NSManagedObjectContext)> +{ + let group: OperationGroup + let context: NSManagedObjectContext + + init(group: OperationGroup, context: NSManagedObjectContext = DatabaseManager.shared.persistentContainer.newBackgroundContext()) + { + self.group = group + self.context = context + + super.init() + } + + override func main() + { + super.main() + + if let error = self.group.error + { + self.finish(.failure(error)) + return + } + + guard + let team = self.group.signer?.team, + let session = self.group.session + else { return self.finish(.failure(OperationError.invalidParameters)) } + + ALTAppleAPI.shared.fetchAppIDs(for: team, session: session) { (appIDs, error) in + self.context.perform { + do + { + let fetchedAppIDs = try Result(appIDs, error).get() + + guard let team = Team.first(satisfying: NSPredicate(format: "%K == %@", #keyPath(Team.identifier), team.identifier), in: self.context) else { throw OperationError.notAuthenticated } + + let fetchedIdentifiers = fetchedAppIDs.map { $0.identifier } + + let deletedAppIDsRequest = AppID.fetchRequest() as NSFetchRequest + deletedAppIDsRequest.predicate = NSPredicate(format: "%K == %@ AND NOT (%K IN %@)", + #keyPath(AppID.team), team, + #keyPath(AppID.identifier), fetchedIdentifiers) + + let deletedAppIDs = try self.context.fetch(deletedAppIDsRequest) + deletedAppIDs.forEach { self.context.delete($0) } + + let appIDs = fetchedAppIDs.map { AppID($0, team: team, context: self.context) } + self.finish(.success((appIDs, self.context))) + } + catch + { + self.finish(.failure(error)) + } + } + } + } +} diff --git a/AltStore/Operations/FetchSourceOperation.swift b/AltStore/Operations/FetchSourceOperation.swift index a8b94874..707ade58 100644 --- a/AltStore/Operations/FetchSourceOperation.swift +++ b/AltStore/Operations/FetchSourceOperation.swift @@ -67,6 +67,16 @@ class FetchSourceOperation: ResultOperation decoder.managedObjectContext = context let source = try decoder.decode(Source.self, from: data) + + if let patreonAccessToken = source.userInfo?[.patreonAccessToken] + { + Keychain.shared.patreonCreatorAccessToken = patreonAccessToken + } + + #if STAGING + source.sourceURL = self.sourceURL + #endif + self.finish(.success(source)) } catch diff --git a/AltStore/Operations/FindServerOperation.swift b/AltStore/Operations/FindServerOperation.swift index 3eb0ef4b..2ba2549e 100644 --- a/AltStore/Operations/FindServerOperation.swift +++ b/AltStore/Operations/FindServerOperation.swift @@ -7,13 +7,26 @@ // import Foundation +import AltKit import Roxas +private extension Notification.Name +{ + static let didReceiveWiredServerConnectionResponse = Notification.Name("io.altstore.didReceiveWiredServerConnectionResponse") +} + +private let ReceivedWiredServerConnectionResponse: @convention(c) (CFNotificationCenter?, UnsafeMutableRawPointer?, CFNotificationName?, UnsafeRawPointer?, CFDictionary?) -> Void = +{ (center, observer, name, object, userInfo) in + NotificationCenter.default.post(name: .didReceiveWiredServerConnectionResponse, object: nil) +} + @objc(FindServerOperation) class FindServerOperation: ResultOperation { let group: OperationGroup + private var isWiredServerConnectionAvailable = false + init(group: OperationGroup) { self.group = group @@ -31,21 +44,49 @@ class FindServerOperation: ResultOperation return } - if let server = ServerManager.shared.discoveredServers.first(where: { $0.isPreferred }) - { - // Preferred server. - self.finish(.success(server)) - } - else if let server = ServerManager.shared.discoveredServers.first - { - // Any available server. - self.finish(.success(server)) - } - else - { - // No servers. - self.finish(.failure(ConnectionError.serverNotFound)) + let notificationCenter = CFNotificationCenterGetDarwinNotifyCenter() + + // Prepare observers to receive callback from wired server (if connected). + CFNotificationCenterAddObserver(notificationCenter, nil, ReceivedWiredServerConnectionResponse, CFNotificationName.wiredServerConnectionAvailableResponse.rawValue, nil, .deliverImmediately) + NotificationCenter.default.addObserver(self, selector: #selector(FindServerOperation.didReceiveWiredServerConnectionResponse(_:)), name: .didReceiveWiredServerConnectionResponse, object: nil) + + // Post notification. + CFNotificationCenterPostNotification(notificationCenter, .wiredServerConnectionAvailableRequest, nil, nil, true) + + // Wait for either callback or timeout. + DispatchQueue.global().asyncAfter(deadline: .now() + 1.0) { + if self.isWiredServerConnectionAvailable + { + let server = Server(isWiredConnection: true) + self.finish(.success(server)) + } + else + { + if let server = ServerManager.shared.discoveredServers.first(where: { $0.isPreferred }) + { + // Preferred server. + self.finish(.success(server)) + } + else if let server = ServerManager.shared.discoveredServers.first + { + // Any available server. + self.finish(.success(server)) + } + else + { + // No servers. + self.finish(.failure(ConnectionError.serverNotFound)) + } + } } } } +private extension FindServerOperation +{ + @objc func didReceiveWiredServerConnectionResponse(_ notification: Notification) + { + self.isWiredServerConnectionAvailable = true + } +} + diff --git a/AltStore/Operations/InstallAppOperation.swift b/AltStore/Operations/InstallAppOperation.swift index 3054f54a..ca7fdc9a 100644 --- a/AltStore/Operations/InstallAppOperation.swift +++ b/AltStore/Operations/InstallAppOperation.swift @@ -18,6 +18,8 @@ class InstallAppOperation: ResultOperation { let context: AppOperationContext + private var didCleanUp = false + init(context: AppOperationContext) { self.context = context @@ -39,12 +41,13 @@ class InstallAppOperation: ResultOperation guard let resignedApp = self.context.resignedApp, - let connection = self.context.connection, - let server = self.context.group.server + let connection = self.context.installationConnection else { return self.finish(.failure(OperationError.invalidParameters)) } let backgroundContext = DatabaseManager.shared.persistentContainer.newBackgroundContext() backgroundContext.perform { + + /* App */ let installedApp: InstalledApp // Fetch + update rather than insert + resolve merge conflicts to prevent potential context-level conflicts. @@ -57,24 +60,64 @@ class InstallAppOperation: ResultOperation installedApp = InstalledApp(resignedApp: resignedApp, originalBundleIdentifier: self.context.bundleIdentifier, context: backgroundContext) } - installedApp.version = resignedApp.version - - if let profile = resignedApp.provisioningProfile + installedApp.update(resignedApp: resignedApp) + + if let team = DatabaseManager.shared.activeTeam(in: backgroundContext) { - installedApp.refreshedDate = profile.creationDate - installedApp.expirationDate = profile.expirationDate + installedApp.team = team } + /* App Extensions */ + var installedExtensions = Set() + + if + let bundle = Bundle(url: resignedApp.fileURL), + let directory = bundle.builtInPlugInsURL, + let enumerator = FileManager.default.enumerator(at: directory, includingPropertiesForKeys: nil, options: [.skipsSubdirectoryDescendants]) + { + for case let fileURL as URL in enumerator + { + guard let appExtensionBundle = Bundle(url: fileURL) else { continue } + guard let appExtension = ALTApplication(fileURL: appExtensionBundle.bundleURL) else { continue } + + let parentBundleID = self.context.bundleIdentifier + let resignedParentBundleID = resignedApp.bundleIdentifier + + let resignedBundleID = appExtension.bundleIdentifier + let originalBundleID = resignedBundleID.replacingOccurrences(of: resignedParentBundleID, with: parentBundleID) + + let installedExtension: InstalledExtension + + if let appExtension = installedApp.appExtensions.first(where: { $0.bundleIdentifier == originalBundleID }) + { + installedExtension = appExtension + } + else + { + installedExtension = InstalledExtension(resignedAppExtension: appExtension, originalBundleIdentifier: originalBundleID, context: backgroundContext) + } + + installedExtension.update(resignedAppExtension: appExtension) + + installedExtensions.insert(installedExtension) + } + } + + installedApp.appExtensions = installedExtensions + + // Temporary directory and resigned .ipa no longer needed, so delete them now to ensure AltStore doesn't quit before we get the chance to. + self.cleanUp() + self.context.group.beginInstallationHandler?(installedApp) let request = BeginInstallationRequest() - server.send(request, via: connection) { (result) in + connection.send(request) { (result) in switch result { case .failure(let error): self.finish(.failure(error)) case .success: - self.receive(from: connection, server: server) { (result) in + self.receive(from: connection) { (result) in switch result { case .success: @@ -92,27 +135,43 @@ class InstallAppOperation: ResultOperation } } - func receive(from connection: NWConnection, server: Server, completionHandler: @escaping (Result) -> Void) + override func finish(_ result: Result) { - server.receive(ServerResponse.self, from: connection) { (result) in + self.cleanUp() + + super.finish(result) + } +} + +private extension InstallAppOperation +{ + func receive(from connection: ServerConnection, completionHandler: @escaping (Result) -> Void) + { + connection.receiveResponse() { (result) in do { let response = try result.get() print(response) - if let error = response.error + switch response { - completionHandler(.failure(error)) - } - else if response.progress == 1.0 - { - self.progress.completedUnitCount = self.progress.totalUnitCount - completionHandler(.success(())) - } - else - { - self.progress.completedUnitCount = Int64(response.progress * 100) - self.receive(from: connection, server: server, completionHandler: completionHandler) + case .installationProgress(let response): + if response.progress == 1.0 + { + self.progress.completedUnitCount = self.progress.totalUnitCount + completionHandler(.success(())) + } + else + { + self.progress.completedUnitCount = Int64(response.progress * 100) + self.receive(from: connection, completionHandler: completionHandler) + } + + case .error(let response): + completionHandler(.failure(response.error)) + + default: + completionHandler(.failure(ALTServerError(.unknownRequest))) } } catch @@ -121,4 +180,25 @@ class InstallAppOperation: ResultOperation } } } + + func cleanUp() + { + guard !self.didCleanUp else { return } + self.didCleanUp = true + + do + { + try FileManager.default.removeItem(at: self.context.temporaryDirectory) + + if let app = self.context.app + { + let fileURL = InstalledApp.refreshedIPAURL(for: app) + try FileManager.default.removeItem(at: fileURL) + } + } + catch + { + print("Failed to remove temporary directory.", error) + } + } } diff --git a/AltStore/Operations/OperationError.swift b/AltStore/Operations/OperationError.swift index 1fe70acc..998d7b20 100644 --- a/AltStore/Operations/OperationError.swift +++ b/AltStore/Operations/OperationError.swift @@ -24,6 +24,8 @@ enum OperationError: LocalizedError case invalidParameters case iOSVersionNotSupported(ALTApplication) + case sideloadingAppNotSupported(ALTApplication) + case maximumAppIDLimitReached(application: ALTApplication, requiredAppIDs: Int, availableAppIDs: Int, nextExpirationDate: Date) case noSources @@ -49,6 +51,53 @@ enum OperationError: LocalizedError let localizedDescription = String(format: NSLocalizedString("%@ requires %@.", comment: ""), name, version) return localizedDescription + + case .sideloadingAppNotSupported(let app): + let localizedDescription = String(format: NSLocalizedString("Sideloading “%@” Not Supported", comment: ""), app.name) + return localizedDescription + + case .maximumAppIDLimitReached: return NSLocalizedString("Cannot register more than 10 App IDs.", comment: "") + } + } + + var recoverySuggestion: String? { + switch self + { + case .maximumAppIDLimitReached(let application, let requiredAppIDs, let availableAppIDs, let date): + let baseMessage = NSLocalizedString("Delete sideloaded apps to free up App ID slots.", comment: "") + let message: String + + if requiredAppIDs > 1 + { + let availableText: String + + switch availableAppIDs + { + case 0: availableText = NSLocalizedString("none are available", comment: "") + case 1: availableText = NSLocalizedString("only 1 is available", comment: "") + default: availableText = String(format: NSLocalizedString("only %@ are available", comment: ""), NSNumber(value: availableAppIDs)) + } + + let prefixMessage = String(format: NSLocalizedString("%@ requires %@ App IDs, but %@.", comment: ""), application.name, NSNumber(value: requiredAppIDs), availableText) + message = prefixMessage + " " + baseMessage + } + else + { + let dateComponents = Calendar.current.dateComponents([.day, .hour, .minute], from: Date(), to: date) + + let dateComponentsFormatter = DateComponentsFormatter() + dateComponentsFormatter.maximumUnitCount = 1 + dateComponentsFormatter.unitsStyle = .full + + let remainingTime = dateComponentsFormatter.string(from: dateComponents)! + + let remainingTimeMessage = String(format: NSLocalizedString("You can register another App ID in %@.", comment: ""), remainingTime) + message = baseMessage + " " + remainingTimeMessage + } + + return message + + default: return nil } } } diff --git a/AltStore/Operations/OperationGroup.swift b/AltStore/Operations/OperationGroup.swift index 83b765f3..3f9feb09 100644 --- a/AltStore/Operations/OperationGroup.swift +++ b/AltStore/Operations/OperationGroup.swift @@ -18,6 +18,8 @@ class OperationGroup var completionHandler: ((Result<[String: Result], Error>) -> Void)? var beginInstallationHandler: ((InstalledApp) -> Void)? + var session: ALTAppleAPISession? + var server: Server? var signer: ALTSigner? @@ -73,7 +75,12 @@ class OperationGroup func progress(for app: AppProtocol) -> Progress? { - let progress = self.progressByBundleIdentifier[app.bundleIdentifier] + return self.progress(forAppWithBundleIdentifier: app.bundleIdentifier) + } + + func progress(forAppWithBundleIdentifier bundleIdentifier: String) -> Progress? + { + let progress = self.progressByBundleIdentifier[bundleIdentifier] return progress } } diff --git a/AltStore/Operations/PrepareDeveloperAccountOperation.swift b/AltStore/Operations/PrepareDeveloperAccountOperation.swift new file mode 100644 index 00000000..cfa21e06 --- /dev/null +++ b/AltStore/Operations/PrepareDeveloperAccountOperation.swift @@ -0,0 +1,81 @@ +// +// PrepareDeveloperAccountOperation.swift +// AltStore +// +// Created by Riley Testut on 1/7/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +import Foundation +import Roxas + +import AltSign + +@objc(PrepareDeveloperAccountOperation) +class PrepareDeveloperAccountOperation: ResultOperation +{ + let group: OperationGroup + + init(group: OperationGroup) + { + self.group = group + + super.init() + + self.progress.totalUnitCount = 2 + } + + override func main() + { + super.main() + + if let error = self.group.error + { + self.finish(.failure(error)) + return + } + + guard + let signer = self.group.signer, + let session = self.group.session + else { return self.finish(.failure(OperationError.invalidParameters)) } + + // Register Device + self.registerCurrentDevice(for: signer.team, session: session) { (result) in + let result = result.map { _ in () } + self.finish(result) + } + } +} + +private extension PrepareDeveloperAccountOperation +{ + func registerCurrentDevice(for team: ALTTeam, session: ALTAppleAPISession, completionHandler: @escaping (Result) -> Void) + { + guard let udid = Bundle.main.object(forInfoDictionaryKey: Bundle.Info.deviceID) as? String else { + return completionHandler(.failure(OperationError.unknownUDID)) + } + + ALTAppleAPI.shared.fetchDevices(for: team, session: session) { (devices, error) in + do + { + let devices = try Result(devices, error).get() + + if let device = devices.first(where: { $0.identifier == udid }) + { + completionHandler(.success(device)) + } + else + { + ALTAppleAPI.shared.registerDevice(name: UIDevice.current.name, identifier: udid, team: team, session: session) { (device, error) in + completionHandler(Result(device, error)) + } + } + } + catch + { + completionHandler(.failure(error)) + } + } + } +} diff --git a/AltStore/Operations/ResignAppOperation.swift b/AltStore/Operations/ResignAppOperation.swift index ec776819..1d3e72a8 100644 --- a/AltStore/Operations/ResignAppOperation.swift +++ b/AltStore/Operations/ResignAppOperation.swift @@ -37,49 +37,45 @@ class ResignAppOperation: ResultOperation guard let app = self.context.app, - let signer = self.context.group.signer + let signer = self.context.group.signer, + let session = self.context.group.session else { return self.finish(.failure(OperationError.invalidParameters)) } - // Register Device - self.registerCurrentDevice(for: signer.team) { (result) in - guard let _ = self.process(result) else { return } + // Prepare Provisioning Profiles + self.prepareProvisioningProfiles(app.fileURL, team: signer.team, session: session) { (result) in + guard let profiles = self.process(result) else { return } - // Prepare Provisioning Profiles - self.prepareProvisioningProfiles(app.fileURL, team: signer.team) { (result) in - guard let profiles = self.process(result) else { return } + // Prepare app bundle + let prepareAppProgress = Progress.discreteProgress(totalUnitCount: 2) + self.progress.addChild(prepareAppProgress, withPendingUnitCount: 3) + + let prepareAppBundleProgress = self.prepareAppBundle(for: app, profiles: profiles) { (result) in + guard let appBundleURL = self.process(result) else { return } - // Prepare app bundle - let prepareAppProgress = Progress.discreteProgress(totalUnitCount: 2) - self.progress.addChild(prepareAppProgress, withPendingUnitCount: 3) + print("Resigning App:", self.context.bundleIdentifier) - let prepareAppBundleProgress = self.prepareAppBundle(for: app, profiles: profiles) { (result) in - guard let appBundleURL = self.process(result) else { return } + // Resign app bundle + let resignProgress = self.resignAppBundle(at: appBundleURL, signer: signer, profiles: Array(profiles.values)) { (result) in + guard let resignedURL = self.process(result) else { return } - print("Resigning App:", self.context.bundleIdentifier) - - // Resign app bundle - let resignProgress = self.resignAppBundle(at: appBundleURL, signer: signer, profiles: Array(profiles.values)) { (result) in - guard let resignedURL = self.process(result) else { return } + // Finish + do + { + let destinationURL = InstalledApp.refreshedIPAURL(for: app) + try FileManager.default.copyItem(at: resignedURL, to: destinationURL, shouldReplace: true) - // Finish - do - { - let destinationURL = InstalledApp.refreshedIPAURL(for: app) - try FileManager.default.copyItem(at: resignedURL, to: destinationURL, shouldReplace: true) - - // Use appBundleURL since we need an app bundle, not .ipa. - guard let resignedApplication = ALTApplication(fileURL: appBundleURL) else { throw OperationError.invalidApp } - self.finish(.success(resignedApplication)) - } - catch - { - self.finish(.failure(error)) - } + // Use appBundleURL since we need an app bundle, not .ipa. + guard let resignedApplication = ALTApplication(fileURL: appBundleURL) else { throw OperationError.invalidApp } + self.finish(.success(resignedApplication)) + } + catch + { + self.finish(.failure(error)) } - prepareAppProgress.addChild(resignProgress, withPendingUnitCount: 1) } - prepareAppProgress.addChild(prepareAppBundleProgress, withPendingUnitCount: 1) + prepareAppProgress.addChild(resignProgress, withPendingUnitCount: 1) } + prepareAppProgress.addChild(prepareAppBundleProgress, withPendingUnitCount: 1) } } @@ -104,114 +100,113 @@ class ResignAppOperation: ResultOperation private extension ResignAppOperation { - func registerCurrentDevice(for team: ALTTeam, completionHandler: @escaping (Result) -> Void) + func prepareProvisioningProfiles(_ fileURL: URL, team: ALTTeam, session: ALTAppleAPISession, completionHandler: @escaping (Result<[String: ALTProvisioningProfile], Error>) -> Void) { - guard let udid = Bundle.main.object(forInfoDictionaryKey: Bundle.Info.deviceID) as? String else { - return completionHandler(.failure(OperationError.unknownUDID)) - } + guard let app = ALTApplication(fileURL: fileURL) else { return completionHandler(.failure(OperationError.invalidApp)) } - ALTAppleAPI.shared.fetchDevices(for: team) { (devices, error) in - do - { - let devices = try Result(devices, error).get() - - if let device = devices.first(where: { $0.identifier == udid }) - { - completionHandler(.success(device)) - } - else - { - ALTAppleAPI.shared.registerDevice(name: UIDevice.current.name, identifier: udid, team: team) { (device, error) in - completionHandler(Result(device, error)) - } - } - } - catch - { - completionHandler(.failure(error)) - } - } - } - - func prepareProvisioningProfiles(_ fileURL: URL, team: ALTTeam, completionHandler: @escaping (Result<[String: ALTProvisioningProfile], Error>) -> Void) - { - guard let bundle = Bundle(url: fileURL), let app = ALTApplication(fileURL: fileURL) else { return completionHandler(.failure(OperationError.invalidApp)) } - - let dispatchGroup = DispatchGroup() - - var profiles = [String: ALTProvisioningProfile]() - var error: Error? - - dispatchGroup.enter() - - self.prepareProvisioningProfile(for: app, team: team) { (result) in - switch result - { - case .failure(let e): error = e - case .success(let profile): - profiles[app.bundleIdentifier] = profile - } - dispatchGroup.leave() - } - - if let directory = bundle.builtInPlugInsURL, let enumerator = FileManager.default.enumerator(at: directory, includingPropertiesForKeys: nil, options: [.skipsSubdirectoryDescendants]) - { - for case let fileURL as URL in enumerator where fileURL.pathExtension.lowercased() == "appex" - { - guard let appExtension = ALTApplication(fileURL: fileURL) else { continue } - - dispatchGroup.enter() - - self.prepareProvisioningProfile(for: appExtension, team: team) { (result) in - switch result - { - case .failure(let e): error = e - case .success(let profile): - profiles[appExtension.bundleIdentifier] = profile - } - dispatchGroup.leave() - } - } - } - - dispatchGroup.notify(queue: .global()) { - if let error = error - { - completionHandler(.failure(error)) - } - else - { - completionHandler(.success(profiles)) - } - } - } - - func prepareProvisioningProfile(for app: ALTApplication, team: ALTTeam, completionHandler: @escaping (Result) -> Void) - { - // Register - self.register(app, team: team) { (result) in + self.prepareProvisioningProfile(for: app, parentApp: nil, team: team, session: session) { (result) in switch result { case .failure(let error): completionHandler(.failure(error)) - case .success(let appID): + case .success(let profile): + var profiles = [app.bundleIdentifier: profile] + var error: Error? - // Update features - self.updateFeatures(for: appID, app: app, team: team) { (result) in - switch result - { - case .failure(let error): completionHandler(.failure(error)) - case .success(let appID): + let dispatchGroup = DispatchGroup() + + for appExtension in app.appExtensions + { + dispatchGroup.enter() + + self.prepareProvisioningProfile(for: appExtension, parentApp: app, team: team, session: session) { (result) in + switch result + { + case .failure(let e): error = e + case .success(let profile): profiles[appExtension.bundleIdentifier] = profile + } - // Update app groups - self.updateAppGroups(for: appID, app: app, team: team) { (result) in - switch result - { - case .failure(let error): completionHandler(.failure(error)) - case .success(let appID): - - // Fetch Provisioning Profile - self.fetchProvisioningProfile(for: appID, team: team) { (result) in - completionHandler(result) + dispatchGroup.leave() + } + } + + dispatchGroup.notify(queue: .global()) { + if let error = error + { + completionHandler(.failure(error)) + } + else + { + completionHandler(.success(profiles)) + } + } + } + } + } + + func prepareProvisioningProfile(for app: ALTApplication, parentApp: ALTApplication?, team: ALTTeam, session: ALTAppleAPISession, completionHandler: @escaping (Result) -> Void) + { + DatabaseManager.shared.persistentContainer.performBackgroundTask { (context) in + + let preferredBundleID: String + + // Check if we have already installed this app with this team before. + let predicate = NSPredicate(format: "%K == %@ AND %K == %@", + #keyPath(InstalledApp.bundleIdentifier), app.bundleIdentifier, + #keyPath(InstalledApp.team.identifier), team.identifier) + if let installedApp = InstalledApp.first(satisfying: predicate, in: context) + { + // This app is already installed, so use the same resigned bundle identifier as before. + // This way, if we change the identifier format (again), AltStore will continue to use + // the old bundle identifier to prevent it from installing as a new app. + preferredBundleID = installedApp.resignedBundleIdentifier + } + else + { + // This app isn't already installed, so create the resigned bundle identifier ourselves. + // Or, if the app _is_ installed but with a different team, we need to create a new + // bundle identifier anyway to prevent collisions with the previous team. + let parentBundleID = parentApp?.bundleIdentifier ?? app.bundleIdentifier + let updatedParentBundleID = parentBundleID + "." + team.identifier // Append just team identifier to make it harder to track. + + preferredBundleID = app.bundleIdentifier.replacingOccurrences(of: parentBundleID, with: updatedParentBundleID) + } + + let preferredName: String + + if let parentApp = parentApp + { + preferredName = "\(parentApp.name) - \(app.name)" + } + else + { + preferredName = app.name + } + + // Register + self.registerAppID(for: app, name: preferredName, bundleIdentifier: preferredBundleID, team: team, session: session) { (result) in + switch result + { + case .failure(let error): completionHandler(.failure(error)) + case .success(let appID): + + // Update features + self.updateFeatures(for: appID, app: app, team: team, session: session) { (result) in + switch result + { + case .failure(let error): completionHandler(.failure(error)) + case .success(let appID): + + // Update app groups + self.updateAppGroups(for: appID, app: app, team: team, session: session) { (result) in + switch result + { + case .failure(let error): completionHandler(.failure(error)) + case .success(let appID): + + // Fetch Provisioning Profile + self.fetchProvisioningProfile(for: appID, team: team, session: session) { (result) in + completionHandler(result) + } } } } @@ -221,24 +216,63 @@ private extension ResignAppOperation } } - func register(_ app: ALTApplication, team: ALTTeam, completionHandler: @escaping (Result) -> Void) + func registerAppID(for application: ALTApplication, name: String, bundleIdentifier: String, team: ALTTeam, session: ALTAppleAPISession, completionHandler: @escaping (Result) -> Void) { - let appName = app.name - let bundleID = "com.\(team.identifier).\(app.bundleIdentifier)" - - ALTAppleAPI.shared.fetchAppIDs(for: team) { (appIDs, error) in + ALTAppleAPI.shared.fetchAppIDs(for: team, session: session) { (appIDs, error) in do { let appIDs = try Result(appIDs, error).get() - if let appID = appIDs.first(where: { $0.bundleIdentifier == bundleID }) + if let appID = appIDs.first(where: { $0.bundleIdentifier == bundleIdentifier }) { completionHandler(.success(appID)) } else { - ALTAppleAPI.shared.addAppID(withName: appName, bundleIdentifier: bundleID, team: team) { (appID, error) in - completionHandler(Result(appID, error)) + let requiredAppIDs = 1 + application.appExtensions.count + let availableAppIDs = max(0, Team.maximumFreeAppIDs - appIDs.count) + + let sortedExpirationDates = appIDs.compactMap { $0.expirationDate }.sorted(by: { $0 < $1 }) + + if team.type == .free + { + if requiredAppIDs > availableAppIDs + { + if let expirationDate = sortedExpirationDates.first + { + throw OperationError.maximumAppIDLimitReached(application: application, requiredAppIDs: requiredAppIDs, availableAppIDs: availableAppIDs, nextExpirationDate: expirationDate) + } + else + { + throw ALTAppleAPIError(.maximumAppIDLimitReached) + } + } + } + + ALTAppleAPI.shared.addAppID(withName: name, bundleIdentifier: bundleIdentifier, team: team, session: session) { (appID, error) in + do + { + do + { + let appID = try Result(appID, error).get() + completionHandler(.success(appID)) + } + catch ALTAppleAPIError.maximumAppIDLimitReached + { + if let expirationDate = sortedExpirationDates.first + { + throw OperationError.maximumAppIDLimitReached(application: application, requiredAppIDs: requiredAppIDs, availableAppIDs: availableAppIDs, nextExpirationDate: expirationDate) + } + else + { + throw ALTAppleAPIError(.maximumAppIDLimitReached) + } + } + } + catch + { + completionHandler(.failure(error)) + } } } } @@ -249,7 +283,7 @@ private extension ResignAppOperation } } - func updateFeatures(for appID: ALTAppID, app: ALTApplication, team: ALTTeam, completionHandler: @escaping (Result) -> Void) + func updateFeatures(for appID: ALTAppID, app: ALTApplication, team: ALTTeam, session: ALTAppleAPISession, completionHandler: @escaping (Result) -> Void) { let requiredFeatures = app.entitlements.compactMap { (entitlement, value) -> (ALTFeature, Any)? in guard let feature = ALTFeature(entitlement: entitlement) else { return nil } @@ -263,15 +297,41 @@ private extension ResignAppOperation features[.appGroups] = true } - let appID = appID.copy() as! ALTAppID - appID.features = features + var updateFeatures = false - ALTAppleAPI.shared.update(appID, team: team) { (appID, error) in - completionHandler(Result(appID, error)) + // Determine whether the required features are already enabled for the AppID. + for (feature, value) in features + { + if let appIDValue = appID.features[feature] as AnyObject?, (value as AnyObject).isEqual(appIDValue) + { + // AppID already has this feature enabled and the values are the same. + continue + } + else + { + // AppID either doesn't have this feature enabled or the value has changed, + // so we need to update it to reflect new values. + updateFeatures = true + break + } + } + + if updateFeatures + { + let appID = appID.copy() as! ALTAppID + appID.features = features + + ALTAppleAPI.shared.update(appID, team: team, session: session) { (appID, error) in + completionHandler(Result(appID, error)) + } + } + else + { + completionHandler(.success(appID)) } } - func updateAppGroups(for appID: ALTAppID, app: ALTApplication, team: ALTTeam, completionHandler: @escaping (Result) -> Void) + func updateAppGroups(for appID: ALTAppID, app: ALTApplication, team: ALTTeam, session: ALTAppleAPISession, completionHandler: @escaping (Result) -> Void) { // TODO: Handle apps belonging to more than one app group. guard let applicationGroups = app.entitlements[.appGroups] as? [String], let groupIdentifier = applicationGroups.first else { @@ -287,7 +347,7 @@ private extension ResignAppOperation // Assign App Group // TODO: Determine whether app already belongs to app group. - ALTAppleAPI.shared.add(appID, to: group, team: team) { (success, error) in + ALTAppleAPI.shared.add(appID, to: group, team: team, session: session) { (success, error) in let result = result.map { _ in appID } completionHandler(result) } @@ -296,7 +356,7 @@ private extension ResignAppOperation let adjustedGroupIdentifier = "group.\(team.identifier)." + groupIdentifier - ALTAppleAPI.shared.fetchAppGroups(for: team) { (groups, error) in + ALTAppleAPI.shared.fetchAppGroups(for: team, session: session) { (groups, error) in switch Result(groups, error) { case .failure(let error): completionHandler(.failure(error)) @@ -311,7 +371,7 @@ private extension ResignAppOperation // Not all characters are allowed in group names, so we replace periods with spaces (like Apple does). let name = "AltStore " + groupIdentifier.replacingOccurrences(of: ".", with: " ") - ALTAppleAPI.shared.addAppGroup(withName: name, groupIdentifier: adjustedGroupIdentifier, team: team) { (group, error) in + ALTAppleAPI.shared.addAppGroup(withName: name, groupIdentifier: adjustedGroupIdentifier, team: team, session: session) { (group, error) in finish(Result(group, error)) } } @@ -319,23 +379,23 @@ private extension ResignAppOperation } } - func fetchProvisioningProfile(for appID: ALTAppID, team: ALTTeam, completionHandler: @escaping (Result) -> Void) + func fetchProvisioningProfile(for appID: ALTAppID, team: ALTTeam, session: ALTAppleAPISession, completionHandler: @escaping (Result) -> Void) { - ALTAppleAPI.shared.fetchProvisioningProfile(for: appID, team: team) { (profile, error) in + ALTAppleAPI.shared.fetchProvisioningProfile(for: appID, team: team, session: session) { (profile, error) in switch Result(profile, error) { case .failure(let error): completionHandler(.failure(error)) case .success(let profile): // Delete existing profile - ALTAppleAPI.shared.delete(profile, for: team) { (success, error) in + ALTAppleAPI.shared.delete(profile, for: team, session: session) { (success, error) in switch Result(success, error) { case .failure(let error): completionHandler(.failure(error)) case .success: // Fetch new provisiong profile - ALTAppleAPI.shared.fetchProvisioningProfile(for: appID, team: team) { (profile, error) in + ALTAppleAPI.shared.fetchProvisioningProfile(for: appID, team: team, session: session) { (profile, error) in completionHandler(Result(profile, error)) } } @@ -371,6 +431,17 @@ private extension ResignAppOperation infoDictionary[Bundle.Info.appGroups] = appGroups } + // Add app-specific exported UTI so we can check later if this app (extension) is installed or not. + let installedAppUTI = ["UTTypeConformsTo": [], + "UTTypeDescription": "AltStore Installed App", + "UTTypeIconFiles": [], + "UTTypeIdentifier": InstalledApp.installedAppUTI(forBundleIdentifier: profile.bundleIdentifier), + "UTTypeTagSpecification": [:]] as [String : Any] + + var exportedUTIs = infoDictionary[Bundle.Info.exportedUTIs] as? [[String: Any]] ?? [] + exportedUTIs.append(installedAppUTI) + infoDictionary[Bundle.Info.exportedUTIs] = exportedUTIs + try (infoDictionary as NSDictionary).write(to: bundle.infoPlistURL) } @@ -400,6 +471,21 @@ private extension ResignAppOperation guard let udid = Bundle.main.object(forInfoDictionaryKey: Bundle.Info.deviceID) as? String else { throw OperationError.unknownUDID } additionalValues[Bundle.Info.deviceID] = udid additionalValues[Bundle.Info.serverID] = UserDefaults.standard.preferredServerID + + if + let data = Keychain.shared.signingCertificate, + let signingCertificate = ALTCertificate(p12Data: data, password: nil), + let encryptingPassword = Keychain.shared.signingCertificatePassword + { + additionalValues[Bundle.Info.certificateID] = signingCertificate.serialNumber + + let encryptedData = signingCertificate.encryptedP12Data(withPassword: encryptingPassword) + try encryptedData?.write(to: appBundle.certificateURL, options: .atomic) + } + else + { + // The embedded certificate + certificate identifier are already in app bundle, no need to update them. + } } // Prepare app diff --git a/AltStore/Operations/SendAppOperation.swift b/AltStore/Operations/SendAppOperation.swift index 558c33ee..e3cc1413 100644 --- a/AltStore/Operations/SendAppOperation.swift +++ b/AltStore/Operations/SendAppOperation.swift @@ -12,13 +12,13 @@ import Network import AltKit @objc(SendAppOperation) -class SendAppOperation: ResultOperation +class SendAppOperation: ResultOperation { let context: AppOperationContext private let dispatchQueue = DispatchQueue(label: "com.altstore.SendAppOperation") - private var connection: NWConnection? + private var serverConnection: ServerConnection? init(context: AppOperationContext) { @@ -45,21 +45,21 @@ class SendAppOperation: ResultOperation let fileURL = InstalledApp.refreshedIPAURL(for: app) // Connect to server. - self.connect(to: server) { (result) in + ServerManager.shared.connect(to: server) { (result) in switch result { case .failure(let error): self.finish(.failure(error)) - case .success(let connection): - self.connection = connection + case .success(let serverConnection): + self.serverConnection = serverConnection // Send app to server. - self.sendApp(at: fileURL, via: connection, server: server) { (result) in + self.sendApp(at: fileURL, via: serverConnection) { (result) in switch result { case .failure(let error): self.finish(.failure(error)) case .success: self.progress.completedUnitCount += 1 - self.finish(.success(connection)) + self.finish(.success(serverConnection)) } } } @@ -69,34 +69,7 @@ class SendAppOperation: ResultOperation private extension SendAppOperation { - func connect(to server: Server, completionHandler: @escaping (Result) -> Void) - { - let connection = NWConnection(to: .service(name: server.service.name, type: server.service.type, domain: server.service.domain, interface: nil), using: .tcp) - - connection.stateUpdateHandler = { [unowned connection] (state) in - switch state - { - case .failed(let error): - print("Failed to connect to service \(server.service.name).", error) - completionHandler(.failure(ConnectionError.connectionFailed)) - - case .cancelled: - completionHandler(.failure(OperationError.cancelled)) - - case .ready: - completionHandler(.success(connection)) - - case .waiting: break - case .setup: break - case .preparing: break - @unknown default: break - } - } - - connection.start(queue: self.dispatchQueue) - } - - func sendApp(at fileURL: URL, via connection: NWConnection, server: Server, completionHandler: @escaping (Result) -> Void) + func sendApp(at fileURL: URL, via connection: ServerConnection, completionHandler: @escaping (Result) -> Void) { do { @@ -106,14 +79,14 @@ private extension SendAppOperation let request = PrepareAppRequest(udid: udid, contentSize: appData.count) print("Sending request \(request)") - server.send(request, via: connection) { (result) in + connection.send(request) { (result) in switch result { case .failure(let error): completionHandler(.failure(error)) case .success: print("Sending app data (\(appData.count) bytes)") - server.send(appData, via: connection, prependSize: false) { (result) in + connection.send(appData, prependSize: false) { (result) in switch result { case .failure(let error): completionHandler(.failure(error)) diff --git a/AltStore/Patreon/PatreonAPI.swift b/AltStore/Patreon/PatreonAPI.swift index 13b83c30..7a5b4d18 100644 --- a/AltStore/Patreon/PatreonAPI.swift +++ b/AltStore/Patreon/PatreonAPI.swift @@ -11,7 +11,6 @@ import AuthenticationServices private let clientID = "ZMx0EGUWe4TVWYXNZZwK_fbIK5jHFVWoUf1Qb-sqNXmT-YzAGwDPxxq7ak3_W5Q2" private let clientSecret = "1hktsZB89QyN69cB4R0tu55R4TCPQGXxvebYUUh7Y-5TLSnRswuxs6OUjdJ74IJt" -private let creatorAccessToken = "NSX1ts9Rf9IzKRCu8GjbwsZ6wll8bDtoJxNbPbp2eZo" private let campaignID = "2863968" @@ -71,7 +70,7 @@ extension PatreonAPI } } -class PatreonAPI +class PatreonAPI: NSObject { static let shared = PatreonAPI() @@ -84,8 +83,9 @@ class PatreonAPI private let session = URLSession(configuration: .ephemeral) private let baseURL = URL(string: "https://www.patreon.com/")! - private init() + private override init() { + super.init() } } @@ -129,6 +129,11 @@ extension PatreonAPI } } + if #available(iOS 13.0, *) + { + self.authenticationSession?.presentationContextProvider = self + } + self.authenticationSession?.start() } @@ -165,7 +170,8 @@ extension PatreonAPI var components = URLComponents(string: "/api/oauth2/v2/campaigns/\(campaignID)/members")! components.queryItems = [URLQueryItem(name: "include", value: "currently_entitled_tiers,currently_entitled_tiers.benefits"), URLQueryItem(name: "fields[tier]", value: "title"), - URLQueryItem(name: "fields[member]", value: "full_name,patron_status")] + URLQueryItem(name: "fields[member]", value: "full_name,patron_status"), + URLQueryItem(name: "page[size]", value: "1000")] let requestURL = components.url(relativeTo: self.baseURL)! @@ -342,7 +348,9 @@ private extension PatreonAPI { case .none: break case .creator: + guard let creatorAccessToken = Keychain.shared.patreonCreatorAccessToken else { return completion(.failure(Error.invalidAccessToken)) } request.setValue("Bearer " + creatorAccessToken, forHTTPHeaderField: "Authorization") + case .user: guard let accessToken = Keychain.shared.patreonAccessToken else { return completion(.failure(Error.notAuthenticated)) } request.setValue("Bearer " + accessToken, forHTTPHeaderField: "Authorization") @@ -384,3 +392,12 @@ private extension PatreonAPI task.resume() } } + +@available(iOS 13.0, *) +extension PatreonAPI: ASWebAuthenticationPresentationContextProviding +{ + func presentationAnchor(for session: ASWebAuthenticationSession) -> ASPresentationAnchor + { + return UIApplication.shared.keyWindow ?? UIWindow() + } +} diff --git a/AltStore/Resources/Assets.xcassets/Colors/Background.colorset/Contents.json b/AltStore/Resources/Assets.xcassets/Colors/Background.colorset/Contents.json new file mode 100644 index 00000000..1ea0e567 --- /dev/null +++ b/AltStore/Resources/Assets.xcassets/Colors/Background.colorset/Contents.json @@ -0,0 +1,38 @@ +{ + "info" : { + "version" : 1, + "author" : "xcode" + }, + "colors" : [ + { + "idiom" : "universal", + "color" : { + "color-space" : "srgb", + "components" : { + "red" : "1.000", + "alpha" : "1.000", + "blue" : "1.000", + "green" : "1.000" + } + } + }, + { + "idiom" : "universal", + "appearances" : [ + { + "appearance" : "luminosity", + "value" : "dark" + } + ], + "color" : { + "color-space" : "srgb", + "components" : { + "red" : "28", + "alpha" : "1.000", + "blue" : "30", + "green" : "28" + } + } + } + ] +} \ No newline at end of file diff --git a/AltStore/Resources/Assets.xcassets/Colors/BlurTint.colorset/Contents.json b/AltStore/Resources/Assets.xcassets/Colors/BlurTint.colorset/Contents.json new file mode 100644 index 00000000..378c34e1 --- /dev/null +++ b/AltStore/Resources/Assets.xcassets/Colors/BlurTint.colorset/Contents.json @@ -0,0 +1,38 @@ +{ + "info" : { + "version" : 1, + "author" : "xcode" + }, + "colors" : [ + { + "idiom" : "universal", + "color" : { + "color-space" : "srgb", + "components" : { + "red" : "255", + "alpha" : "0.300", + "blue" : "255", + "green" : "255" + } + } + }, + { + "idiom" : "universal", + "appearances" : [ + { + "appearance" : "luminosity", + "value" : "dark" + } + ], + "color" : { + "color-space" : "srgb", + "components" : { + "red" : "0", + "alpha" : "0.300", + "blue" : "0", + "green" : "0" + } + } + } + ] +} \ No newline at end of file diff --git a/AltStore/Resources/Assets.xcassets/Colors/SettingsBackground.colorset/Contents.json b/AltStore/Resources/Assets.xcassets/Colors/SettingsBackground.colorset/Contents.json new file mode 100644 index 00000000..ba4b0d05 --- /dev/null +++ b/AltStore/Resources/Assets.xcassets/Colors/SettingsBackground.colorset/Contents.json @@ -0,0 +1,38 @@ +{ + "info" : { + "version" : 1, + "author" : "xcode" + }, + "colors" : [ + { + "idiom" : "universal", + "color" : { + "color-space" : "srgb", + "components" : { + "red" : "1", + "alpha" : "1.000", + "blue" : "132", + "green" : "128" + } + } + }, + { + "idiom" : "universal", + "appearances" : [ + { + "appearance" : "luminosity", + "value" : "dark" + } + ], + "color" : { + "color-space" : "srgb", + "components" : { + "red" : "2", + "alpha" : "1.000", + "blue" : "103", + "green" : "82" + } + } + } + ] +} \ No newline at end of file diff --git a/AltStore/Resources/Assets.xcassets/Colors/SettingsHighlighted.colorset/Contents.json b/AltStore/Resources/Assets.xcassets/Colors/SettingsHighlighted.colorset/Contents.json new file mode 100644 index 00000000..14f49d48 --- /dev/null +++ b/AltStore/Resources/Assets.xcassets/Colors/SettingsHighlighted.colorset/Contents.json @@ -0,0 +1,38 @@ +{ + "info" : { + "version" : 1, + "author" : "xcode" + }, + "colors" : [ + { + "idiom" : "universal", + "color" : { + "color-space" : "srgb", + "components" : { + "red" : "0.008", + "alpha" : "1.000", + "blue" : "0.404", + "green" : "0.322" + } + } + }, + { + "idiom" : "universal", + "appearances" : [ + { + "appearance" : "luminosity", + "value" : "dark" + } + ], + "color" : { + "color-space" : "srgb", + "components" : { + "red" : "0.004", + "alpha" : "1.000", + "blue" : "0.518", + "green" : "0.502" + } + } + } + ] +} \ No newline at end of file diff --git a/AltStore/Resources/apps.json b/AltStore/Resources/apps.json index 90b8aa5a..f3a6a8c4 100644 --- a/AltStore/Resources/apps.json +++ b/AltStore/Resources/apps.json @@ -7,14 +7,14 @@ "name": "AltStore", "bundleIdentifier": "com.rileytestut.AltStore", "developerName": "Riley Testut", - "version": "1.0.1", - "versionDate": "2019-09-28T03:00:00-07:00", - "versionDescription": "Fixes Patreon bugs.", + "version": "1.2", + "versionDate": "2020-02-12T08:00:00-08:00", + "versionDescription": "FEATURES\n• Install and refresh apps over USB, not just WiFi (requires updating to latest AltServer version)\n• Supports sideloading unc0ver (support for sideloading any app coming soon)\n\nBUG FIXES\n• Fixes \"Device Already Registered\" error\n• Fixes \"Session Expired\" error when installing apps on slow connection", "downloadURL": "https://f000.backblazeb2.com/file/altstore/altstore.ipa", "localizedDescription": "AltStore is an alternative app store for non-jailbroken devices. \n\nThis initial release of AltStore allows you to install Delta, an all-in-one emulator for iOS, with support for installing 3rd party apps coming soon.", "iconURL": "https://user-images.githubusercontent.com/705880/65270980-1eb96f80-dad1-11e9-9367-78ccd25ceb02.png", "tintColor": "018084", - "size": 3481256, + "size": 2114068, "screenshotURLs": [ "https://user-images.githubusercontent.com/705880/65605563-2f009d00-df5e-11e9-9b40-1f36135d5c80.PNG", "https://user-images.githubusercontent.com/705880/65605569-30ca6080-df5e-11e9-8dfb-15ebb00e10cb.PNG", @@ -35,14 +35,15 @@ "name": "AltStore", "bundleIdentifier": "com.rileytestut.AltStore.Beta", "developerName": "Riley Testut", - "version": "1.0.1b", - "versionDate": "2019-09-28T03:00:00-07:00", - "versionDescription": "- Adds support for sideloading apps via \"Open In...\"\n- Fixes Patreon bugs", + "subtitle": "An alternative App Store for iOS.", + "version": "1.2b4", + "versionDate": "2020-02-11T18:30:00-08:00", + "versionDescription": "• View all registered App IDs for your account\n• Fixed inaccurate remaining App ID count\n\nThis is the final beta for AltStore 1.2 before the public release, which includes support for installing apps completely over USB. To test installing over USB, make sure to download the AltServer beta from https://altstore.io/altserver/beta", "downloadURL": "https://f000.backblazeb2.com/file/altstore/altstore-beta.ipa", "localizedDescription": "AltStore is an alternative app store for non-jailbroken devices. \n\nThis beta release of AltStore allows you to install Delta as well as any app (.ipa) directly from the Files app.", "iconURL": "https://user-images.githubusercontent.com/705880/65270980-1eb96f80-dad1-11e9-9367-78ccd25ceb02.png", "tintColor": "018084", - "size": 3481256, + "size": 2114670, "beta": true, "screenshotURLs": [ "https://user-images.githubusercontent.com/705880/65605563-2f009d00-df5e-11e9-9b40-1f36135d5c80.PNG", @@ -65,14 +66,14 @@ "bundleIdentifier": "com.rileytestut.Delta", "developerName": "Riley Testut", "subtitle": "Classic games in your pocket.", - "version": "1.0", - "versionDate": "2019-09-28T12:00:00-07:00", - "versionDescription": "Initial version.", + "version": "1.1.2", + "versionDate": "2020-02-04T15:30:00-08:00", + "versionDescription": "• Fixes crash when running on iOS 13.3.1", "downloadURL": "https://f000.backblazeb2.com/file/altstore/delta.ipa", "localizedDescription": "Delta is an all-in-one emulator for iOS. Delta builds upon the strengths of its predecessor, GBA4iOS, while expanding to include support for more game systems such as NES, SNES, and N64.\n\nFEATURES\n\nSupported Game Systems\n• Nintendo Entertainment System\n• Super Nintendo Entertainment System\n• Nintendo 64\n• Game Boy (Color)\n• Game Boy Advance\n• And plenty more to come!\n\nController Support\n• Supports PS4, Xbox One S, and MFi game controllers.\n• Supports bluetooth (and wired) keyboards, as well as the Apple Smart Keyboard.\n• Completely customize button mappings on a per-system, per-controller basis.\n• Map buttons to special “Quick Save”, “Quick Load,” and “Fast Forward” actions.\n\nSave States\n• Save and load save states for any game from the pause menu.\n• Lock save states to prevent them from being accidentally overwritten.\n• Automatically makes backup save states to ensure you never lose your progress.\n• Support for “Quick Saves,” save states that can be quickly saved/loaded with a single button press (requires external controller).\n\nCheats\n• Supports various types of cheat codes for each supported system:\n• NES: Game Genie\n• SNES: Game Genie, Pro Action Replay\n• N64: GameShark\n• GBC: Game Genie, GameShark\n• GBA: Action Replay, Code Breaker, GameShark\n\nDelta Sync\n• Sync your games, game saves, save states, cheats, controller skins, and controller mappings between devices.\n• View version histories of everything you sync and optionally restore them to earlier versions.\n• Supports both Google Drive and Dropbox.\n\nCustom Controller Skins\n• Beautiful built-in controller skins for all systems.\n• Import controller skins made by others, or even make your own to share with the world!\n\nHold Button\n• Choose buttons for Delta to hold down on your behalf, freeing up your thumbs to press other buttons instead.\n• Perfect for games that typically require one button be held down constantly (ex: run button in Mario games, or the A button in Mario Kart).\n\nFast Forward\n• Speed through slower parts of games by running the game much faster than normal.\n• Easily enable or disable from the pause menu, or optionally with a mapped button on an external controller.\n\n3D/Haptic Touch\n• Use 3D or Haptic Touch to “peek” at games, save states, and cheat codes.\n• App icon shortcuts allow quick access to your most recently played games, or optionally customize the shortcuts to always include certain games.\n\nGame Artwork\n• Automatically displays appropriate box art for imported games.\n• Change a game’s artwork to anything you want, or select from the built-in game artwork database.\n\nMisc.\n• Gyroscope support for WarioWare: Twisted!\n• Support for delta:// URL scheme to jump directly into a specific game.\n\n**Delta and AltStore LLC are in no way affiliated with Nintendo. The name \"Nintendo\" and all associated game console names are registered trademarks of Nintendo Co., Ltd.**", "iconURL": "https://user-images.githubusercontent.com/705880/63391976-4d311700-c37a-11e9-91a8-4fb0c454413d.png", "tintColor": "8A28F7", - "size": 23075523, + "size": 17542718, "permissions": [ { "type": "photos", @@ -91,14 +92,14 @@ "bundleIdentifier": "com.rileytestut.Delta.Beta", "developerName": "Riley Testut", "subtitle": "Classic games in your pocket.", - "version": "1.0b", - "versionDate": "2019-09-28T12:00:00-07:00", - "versionDescription": "Includes initial support for DS games.", + "version": "1.2b", + "versionDate": "2020-02-11T16:30:00-08:00", + "versionDescription": "GENERAL\n• Replaces 3D Touch peek/pop with iOS 13 context menus\n\nCONTROLLER SKINS\n• Brand new Nintendo DS controller skin\n• New Quick Save, Quick Load, and Fast Forward inputs for controller skins\n• Apply video filters with controller skins\n• Assign controller skins to individual games", "downloadURL": "https://f000.backblazeb2.com/file/altstore/delta-beta.ipa", "localizedDescription": "The next console for Delta is coming: this beta version of Delta brings support for playing DS games!\n\nDS support currently includes:\n• Playing DS games\n• Save States\n• Hold Button\n\nFeatures I'm still working on:\n• Fast Forward\n• Cheats\n• Controller skin (using placeholder controller skin for now)\n\nPlease report any issues you find to support@altstore.io. Thanks!", "iconURL": "https://user-images.githubusercontent.com/705880/63391976-4d311700-c37a-11e9-91a8-4fb0c454413d.png", "tintColor": "8A28F7", - "size": 23075071, + "size": 17631726, "beta": true, "permissions": [ { @@ -114,6 +115,31 @@ "https://user-images.githubusercontent.com/705880/65601117-58b5c600-df56-11e9-9c19-9a5ba5da54cf.PNG" ] }, + { + "name": "Clip", + "bundleIdentifier": "com.rileytestut.Clip.Beta", + "subtitle": "Manage your clipboard history with ease.", + "developerName": "Riley Testut", + "version": "1.0b", + "versionDate": "2019-01-24T18:20:00-08:00", + "versionDescription": "• Disables notification vibration when sound is disabled for notifications.\n\nAssuming all goes well, this should be the final beta before the public launch! Please report any last minute bugs you find to support@altstore.io.", + "downloadURL": "https://f000.backblazeb2.com/file/altstore/clip-beta.ipa", + "localizedDescription": "Clip is a simple clipboard manager for iOS. \n\nUnlike other clipboard managers, Clip can continue monitoring your clipboard while in the background. No longer do you need to remember to manually open or share to an app to save your clipboard; just copy and paste as you would normally do, and Clip will have your back.\n\nIn addition to background monitoring, Clip also has these features:\n\n• Save text, URLs, and images copied to the clipboard.\n• Copy, delete, or share any clippings saved to Clip.\n• Customizable history limit.\n\nDownload Clip today, and never worry about losing your clipboard again!", + "iconURL": "https://user-images.githubusercontent.com/705880/63391981-5326f800-c37a-11e9-99d8-760fd06bb601.png", + "tintColor": "EC008C", + "size": 462771, + "beta": true, + "permissions": [ + { + "type": "background-audio", + "usageDescription": "Allows Clip to continuously monitor your clipboard in the background." + } + ], + "screenshotURLs": [ + "https://user-images.githubusercontent.com/705880/63391950-34286600-c37a-11e9-965f-832efe3da507.png", + "https://user-images.githubusercontent.com/705880/70830209-8e738980-1da4-11ea-8b3b-6e5fbc78adff.png" + ] + }, { "name": "Delta Lite", "bundleIdentifier": "com.rileytestut.Delta.Lite", @@ -194,12 +220,17 @@ "notify": false }, { - "title": "Prevent AltStore Expiring", - "identifier": "altstore-expiring-bug-fix", - "caption": "Refresh AltStore at least once in “My Apps” to prevent it from expiring early. An update is coming soon to fix this bug.", - "tintColor": "fd423a", - "date": "2019-10-09", + "title": "Coming Soon: Clip", + "identifier": "clip-coming-soon", + "caption": "A clipboard manager that can run in the background. Beta available now for all Patrons.", + "tintColor": "EC008C", + "url": "https://twitter.com/altstoreio/status/1205597959699582977", + "imageURL": "https://user-images.githubusercontent.com/705880/65606598-04afdf00-df60-11e9-8f93-af6345d39557.png", + "date": "2019-12-16", "notify": false } - ] + ], + "userInfo": { + "patreonAccessToken": "JLh5bpOQsPg-HIRe6FHnRAktoeeU4JT5-Xk-y7njQrM" + } } diff --git a/AltStore/Server/Server.swift b/AltStore/Server/Server.swift index 451306ff..568d091d 100644 --- a/AltStore/Server/Server.swift +++ b/AltStore/Server/Server.swift @@ -44,139 +44,22 @@ enum ConnectionError: LocalizedError struct Server: Equatable { - var identifier: String - var service: NetService + var identifier: String? = nil + var service: NetService? = nil var isPreferred = false - + var isWiredConnection = false +} + +extension Server +{ + // Defined in extension so we can still use the automatically synthesized initializer. init?(service: NetService, txtData: Data) - { + { let txtDictionary = NetService.dictionary(fromTXTRecord: txtData) guard let identifierData = txtDictionary["serverID"], let identifier = String(data: identifierData, encoding: .utf8) else { return nil } - self.identifier = identifier self.service = service - } - - func send(_ payload: T, via connection: NWConnection, prependSize: Bool = true, completionHandler: @escaping (Result) -> Void) - { - do - { - let data: Data - - if let payload = payload as? Data - { - data = payload - } - else - { - data = try JSONEncoder().encode(payload) - } - - func process(_ error: Error?) -> Bool - { - if error != nil - { - completionHandler(.failure(ConnectionError.connectionDropped)) - return false - } - else - { - return true - } - } - - if prependSize - { - let requestSize = Int32(data.count) - let requestSizeData = withUnsafeBytes(of: requestSize) { Data($0) } - - connection.send(content: requestSizeData, completion: .contentProcessed { (error) in - guard process(error) else { return } - - connection.send(content: data, completion: .contentProcessed { (error) in - guard process(error) else { return } - completionHandler(.success(())) - }) - }) - - } - else - { - connection.send(content: data, completion: .contentProcessed { (error) in - guard process(error) else { return } - completionHandler(.success(())) - }) - } - } - catch - { - print("Invalid request.", error) - completionHandler(.failure(ALTServerError(.invalidRequest))) - } - } - - func receive(_ type: T.Type, from connection: NWConnection, completionHandler: @escaping (Result) -> Void) - { - let size = MemoryLayout.size - - connection.receive(minimumIncompleteLength: size, maximumLength: size) { (data, _, _, error) in - do - { - let data = try self.process(data: data, error: error, from: connection) - - let expectedBytes = Int(data.withUnsafeBytes { $0.load(as: Int32.self) }) - connection.receive(minimumIncompleteLength: expectedBytes, maximumLength: expectedBytes) { (data, _, _, error) in - do - { - let data = try self.process(data: data, error: error, from: connection) - - let response = try JSONDecoder().decode(T.self, from: data) - completionHandler(.success(response)) - } - catch - { - completionHandler(.failure(ALTServerError(error))) - } - } - } - catch - { - completionHandler(.failure(ALTServerError(error))) - } - } - } -} - -private extension Server -{ - func process(data: Data?, error: NWError?, from connection: NWConnection) throws -> Data - { - do - { - do - { - guard let data = data else { throw error ?? ALTServerError(.unknown) } - return data - } - catch let error as NWError - { - print("Error receiving data from connection \(connection)", error) - - throw ALTServerError(.lostConnection) - } - catch - { - throw error - } - } - catch let error as ALTServerError - { - throw error - } - catch - { - preconditionFailure("A non-ALTServerError should never be thrown from this method.") - } + self.identifier = identifier } } diff --git a/AltStore/Server/ServerConnection.swift b/AltStore/Server/ServerConnection.swift new file mode 100644 index 00000000..76d56274 --- /dev/null +++ b/AltStore/Server/ServerConnection.swift @@ -0,0 +1,146 @@ +// +// ServerConnection.swift +// AltStore +// +// Created by Riley Testut on 1/7/20. +// Copyright © 2020 Riley Testut. All rights reserved. +// + +import Foundation +import Network + +import AltKit + +class ServerConnection +{ + var server: Server + var connection: NWConnection + + init(server: Server, connection: NWConnection) + { + self.server = server + self.connection = connection + } + + func send(_ payload: T, prependSize: Bool = true, completionHandler: @escaping (Result) -> Void) + { + do + { + let data: Data + + if let payload = payload as? Data + { + data = payload + } + else + { + data = try JSONEncoder().encode(payload) + } + + func process(_ error: Error?) -> Bool + { + if error != nil + { + completionHandler(.failure(ConnectionError.connectionDropped)) + return false + } + else + { + return true + } + } + + if prependSize + { + let requestSize = Int32(data.count) + let requestSizeData = withUnsafeBytes(of: requestSize) { Data($0) } + + self.connection.send(content: requestSizeData, completion: .contentProcessed { (error) in + guard process(error) else { return } + + self.connection.send(content: data, completion: .contentProcessed { (error) in + guard process(error) else { return } + completionHandler(.success(())) + }) + }) + + } + else + { + connection.send(content: data, completion: .contentProcessed { (error) in + guard process(error) else { return } + completionHandler(.success(())) + }) + } + } + catch + { + print("Invalid request.", error) + completionHandler(.failure(ALTServerError(.invalidRequest))) + } + } + + func receiveResponse(completionHandler: @escaping (Result) -> Void) + { + let size = MemoryLayout.size + + self.connection.receive(minimumIncompleteLength: size, maximumLength: size) { (data, _, _, error) in + do + { + let data = try self.process(data: data, error: error) + + let expectedBytes = Int(data.withUnsafeBytes { $0.load(as: Int32.self) }) + self.connection.receive(minimumIncompleteLength: expectedBytes, maximumLength: expectedBytes) { (data, _, _, error) in + do + { + let data = try self.process(data: data, error: error) + + let response = try JSONDecoder().decode(ServerResponse.self, from: data) + completionHandler(.success(response)) + } + catch + { + completionHandler(.failure(ALTServerError(error))) + } + } + } + catch + { + completionHandler(.failure(ALTServerError(error))) + } + } + } +} + +private extension ServerConnection +{ + func process(data: Data?, error: NWError?) throws -> Data + { + do + { + do + { + guard let data = data else { throw error ?? ALTServerError(.unknown) } + return data + } + catch let error as NWError + { + print("Error receiving data from connection \(connection)", error) + + throw ALTServerError(.lostConnection) + } + catch + { + throw error + } + } + catch let error as ALTServerError + { + throw error + } + catch + { + preconditionFailure("A non-ALTServerError should never be thrown from this method.") + } + } +} diff --git a/AltStore/Server/ServerManager.swift b/AltStore/Server/ServerManager.swift index a11d1550..5e8ccf5b 100644 --- a/AltStore/Server/ServerManager.swift +++ b/AltStore/Server/ServerManager.swift @@ -19,9 +19,14 @@ class ServerManager: NSObject private(set) var discoveredServers = [Server]() private let serviceBrowser = NetServiceBrowser() - private var services = Set() + private let dispatchQueue = DispatchQueue(label: "io.altstore.ServerManager") + + private var connectionListener: NWListener? + private var incomingConnections: [NWConnection]? + private var incomingConnectionsSemaphore: DispatchSemaphore? + private override init() { super.init() @@ -39,6 +44,8 @@ extension ServerManager self.isDiscovering = true self.serviceBrowser.searchForServices(ofType: ALTServerServiceType, inDomain: "") + + self.startListeningForWiredConnections() } func stopDiscovering() @@ -49,6 +56,68 @@ extension ServerManager self.discoveredServers.removeAll() self.services.removeAll() self.serviceBrowser.stop() + + self.stopListeningForWiredConnection() + } + + func connect(to server: Server, completion: @escaping (Result) -> Void) + { + DispatchQueue.global().async { + func finish(_ result: Result) + { + completion(result) + } + + func start(_ connection: NWConnection) + { + connection.stateUpdateHandler = { [unowned connection] (state) in + switch state + { + case .failed(let error): + print("Failed to connect to service \(server.service?.name ?? "").", error) + finish(.failure(ConnectionError.connectionFailed)) + + case .cancelled: + finish(.failure(OperationError.cancelled)) + + case .ready: + let connection = ServerConnection(server: server, connection: connection) + finish(.success(connection)) + + case .waiting: break + case .setup: break + case .preparing: break + @unknown default: break + } + } + + connection.start(queue: self.dispatchQueue) + } + + if let incomingConnectionsSemaphore = self.incomingConnectionsSemaphore, server.isWiredConnection + { + print("Waiting for new wired connection...") + + let notificationCenter = CFNotificationCenterGetDarwinNotifyCenter() + CFNotificationCenterPostNotification(notificationCenter, .wiredServerConnectionStartRequest, nil, nil, true) + + _ = incomingConnectionsSemaphore.wait(timeout: .now() + 10.0) + + if let connection = self.incomingConnections?.popLast() + { + start(connection) + } + else + { + finish(.failure(ALTServerError(.connectionFailed))) + } + } + else if let service = server.service + { + let connection = NWConnection(to: .service(name: service.name, type: service.type, domain: service.domain, interface: nil), using: .tcp) + start(connection) + } + } } } @@ -63,6 +132,45 @@ private extension ServerManager self.discoveredServers.append(server) } + + func makeListener() -> NWListener + { + let listener = try! NWListener(using: .tcp, on: NWEndpoint.Port(rawValue: ALTDeviceListeningSocket)!) + listener.newConnectionHandler = { [weak self] (connection) in + self?.incomingConnections?.append(connection) + self?.incomingConnectionsSemaphore?.signal() + } + listener.stateUpdateHandler = { (state) in + switch state + { + case .ready: break + case .waiting, .setup: print("Listener socket waiting...") + case .cancelled: print("Listener socket cancelled.") + case .failed(let error): print("Listener socket failed:", error) + @unknown default: break + } + } + + return listener + } + + func startListeningForWiredConnections() + { + self.incomingConnections = [] + self.incomingConnectionsSemaphore = DispatchSemaphore(value: 0) + + self.connectionListener = self.makeListener() + self.connectionListener?.start(queue: self.dispatchQueue) + } + + func stopListeningForWiredConnection() + { + self.connectionListener?.cancel() + self.connectionListener = nil + + self.incomingConnections = nil + self.incomingConnectionsSemaphore = nil + } } extension ServerManager: NetServiceBrowserDelegate diff --git a/AltStore/Settings/AboutPatreonHeaderView.xib b/AltStore/Settings/AboutPatreonHeaderView.xib index 09227294..8ed7b0cf 100644 --- a/AltStore/Settings/AboutPatreonHeaderView.xib +++ b/AltStore/Settings/AboutPatreonHeaderView.xib @@ -1,11 +1,9 @@ - - - - + + - + @@ -74,24 +72,24 @@ Riley @@ -111,12 +109,13 @@ Riley + - - - + + + diff --git a/AltStore/Settings/LicensesViewController.swift b/AltStore/Settings/LicensesViewController.swift index 748343c3..66b50736 100644 --- a/AltStore/Settings/LicensesViewController.swift +++ b/AltStore/Settings/LicensesViewController.swift @@ -14,6 +14,10 @@ class LicensesViewController: UIViewController @IBOutlet private var textView: UITextView! + override var preferredStatusBarStyle: UIStatusBarStyle { + return .lightContent + } + override func viewWillAppear(_ animated: Bool) { super.viewWillAppear(animated) diff --git a/AltStore/Settings/PatreonViewController.swift b/AltStore/Settings/PatreonViewController.swift index 827a77dd..ffb105f4 100644 --- a/AltStore/Settings/PatreonViewController.swift +++ b/AltStore/Settings/PatreonViewController.swift @@ -30,6 +30,10 @@ class PatreonViewController: UICollectionViewController private var patronsResult: Result<[Patron], Error>? + override var preferredStatusBarStyle: UIStatusBarStyle { + return .lightContent + } + override func viewDidLoad() { super.viewDidLoad() diff --git a/AltStore/Settings/Settings.storyboard b/AltStore/Settings/Settings.storyboard index a9413989..18dcb557 100644 --- a/AltStore/Settings/Settings.storyboard +++ b/AltStore/Settings/Settings.storyboard @@ -1,11 +1,9 @@ - - - - + + - + @@ -18,14 +16,21 @@ - + + - + @@ -55,7 +60,7 @@ - + @@ -87,7 +92,7 @@ - + @@ -119,7 +124,7 @@ - + @@ -155,7 +160,7 @@ - + @@ -195,7 +200,7 @@ - + @@ -235,7 +240,7 @@ - + @@ -275,20 +280,20 @@ - + - + - + - + - + - + - + - +