passepartout-apple/Passepartout/App/Shared/InApp/ProductManager.swift

314 lines
9.5 KiB
Swift

//
// ProductManager.swift
// Passepartout
//
// Created by Davide De Rosa on 4/6/19.
// Copyright (c) 2022 Davide De Rosa. All rights reserved.
//
// https://github.com/passepartoutvpn
//
// This file is part of Passepartout.
//
// Passepartout is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Passepartout is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Passepartout. If not, see <http://www.gnu.org/licenses/>.
//
import Foundation
import PassepartoutCore
import StoreKit
import Kvitto
enum ProductError: Error {
case uneligible
case beta
}
@MainActor
class ProductManager: NSObject, ObservableObject {
enum AppType: Int {
case freemium = 0
case beta = 1
case fullVersion = 2
}
struct Configuration {
let appType: AppType
let lastFullVersionBuild: (Int, LocalProduct)
let lastNetworkSettingsBuild: Int
init(
appType: AppType,
lastFullVersionBuild: (Int, LocalProduct),
lastNetworkSettingsBuild: Int
) {
self.appType = appType
self.lastFullVersionBuild = lastFullVersionBuild
self.lastNetworkSettingsBuild = lastNetworkSettingsBuild
}
}
let cfg: Configuration
@Published private(set) var isRefreshingProducts = false
@Published private(set) var products: [SKProduct]
//
private let inApp: InApp<LocalProduct>
private var purchasedAppBuild: Int?
private var purchasedFeatures: Set<LocalProduct>
private var purchaseDates: [LocalProduct: Date]
private var cancelledPurchases: Set<LocalProduct>
private var refreshRequest: SKReceiptRefreshRequest?
init(_ cfg: Configuration) {
self.cfg = cfg
products = []
inApp = InApp()
purchasedAppBuild = nil
purchasedFeatures = []
purchaseDates = [:]
cancelledPurchases = []
super.init()
reloadReceipt()
SKPaymentQueue.default().add(self)
refreshProducts()
}
deinit {
SKPaymentQueue.default().remove(self)
}
func canMakePayments() -> Bool {
SKPaymentQueue.canMakePayments()
}
func refreshProducts() {
let ids = LocalProduct.all
guard !ids.isEmpty else {
return
}
isRefreshingProducts = true
inApp.requestProducts(withIdentifiers: ids, completionHandler: { _ in
pp_log.debug("In-app products: \(self.inApp.products.map { $0.productIdentifier })")
self.products = self.inApp.products
self.isRefreshingProducts = false
}, failureHandler: {
pp_log.warning("Unable to list products: \($0)")
self.isRefreshingProducts = false
})
}
func product(withIdentifier identifier: LocalProduct) -> SKProduct? {
return inApp.product(withIdentifier: identifier)
}
func featureProducts(including: [LocalProduct]) -> [SKProduct] {
return inApp.products.filter {
guard let p = LocalProduct(rawValue: $0.productIdentifier) else {
return false
}
guard including.contains(p) else {
return false
}
guard p.isFeature else {
return false
}
return true
}
}
func featureProducts(excluding: [LocalProduct]) -> [SKProduct] {
return inApp.products.filter {
guard let p = LocalProduct(rawValue: $0.productIdentifier) else {
return false
}
guard !excluding.contains(p) else {
return false
}
guard p.isFeature else {
return false
}
return true
}
}
func purchase(_ product: SKProduct, completionHandler: @escaping (Result<InAppPurchaseResult, Error>) -> Void) {
inApp.purchase(product: product) { result in
if case .success = result {
self.reloadReceipt()
}
DispatchQueue.main.async {
completionHandler(result)
}
}
}
func restorePurchases(completionHandler: @escaping (Error?) -> Void) {
inApp.restorePurchases { (finished, _, error) in
guard finished else {
return
}
DispatchQueue.main.async {
completionHandler(error)
}
}
}
// MARK: In-app eligibility
private func isCurrentPlatformVersion() -> Bool {
#if os(iOS)
return purchasedFeatures.contains(.fullVersion_iOS)
#else
return purchasedFeatures.contains(.fullVersion_macOS)
#endif
}
private func isFullVersion() -> Bool {
if cfg.appType == .fullVersion {
return true
}
if isCurrentPlatformVersion() {
return true
}
return purchasedFeatures.contains(.fullVersion)
}
func isEligible(forFeature feature: LocalProduct) -> Bool {
if let purchasedAppBuild = purchasedAppBuild {
if feature == .networkSettings && purchasedAppBuild <= cfg.lastNetworkSettingsBuild {
return true
}
}
#if os(iOS)
return isFullVersion() || purchasedFeatures.contains(feature)
#else
return isFullVersion()
#endif
}
func isEligible(forProvider providerName: ProviderName) -> Bool {
isEligible(forFeature: providerName.product)
}
func isEligibleForFeedback() -> Bool {
return cfg.appType == .beta || !purchasedFeatures.isEmpty
}
func hasPurchased(_ product: LocalProduct) -> Bool {
return purchasedFeatures.contains(product)
}
func isCancelledPurchase(_ product: LocalProduct) -> Bool {
return cancelledPurchases.contains(product)
}
func purchaseDate(forProduct product: LocalProduct) -> Date? {
return purchaseDates[product]
}
func reloadReceipt(andNotify: Bool = true) {
guard let url = Bundle.main.appStoreReceiptURL else {
pp_log.warning("No App Store receipt found!")
return
}
guard let receipt = Receipt(contentsOfURL: url) else {
pp_log.error("Could not parse App Store receipt!")
return
}
if let originalAppVersion = receipt.originalAppVersion, let buildNumber = Int(originalAppVersion) {
purchasedAppBuild = buildNumber
}
purchasedFeatures.removeAll()
cancelledPurchases.removeAll()
if let buildNumber = purchasedAppBuild {
pp_log.debug("Original purchased build: \(buildNumber)")
// treat former purchases as full versions
if buildNumber <= cfg.lastFullVersionBuild.0 {
purchasedFeatures.insert(cfg.lastFullVersionBuild.1)
}
}
if let iapReceipts = receipt.inAppPurchaseReceipts {
purchaseDates.removeAll()
pp_log.debug("In-app receipts:")
iapReceipts.forEach {
guard let pid = $0.productIdentifier, let product = LocalProduct(rawValue: pid) else {
return
}
if let cancellationDate = $0.cancellationDate {
pp_log.debug("\t\(pid) [cancelled on: \(cancellationDate)]")
cancelledPurchases.insert(product)
return
}
if let purchaseDate = $0.originalPurchaseDate {
pp_log.debug("\t\(pid) [purchased on: \(purchaseDate)]")
purchaseDates[product] = purchaseDate
}
purchasedFeatures.insert(product)
}
}
pp_log.info("Purchased features: \(purchasedFeatures)")
if andNotify {
objectWillChange.send()
}
}
}
extension ProductManager: SKPaymentTransactionObserver {
func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {
DispatchQueue.main.async { [weak self] in
self?.reloadReceipt()
}
}
}
extension ProductManager {
func hasRefunded() -> Bool {
reloadReceipt(andNotify: false)
let isEligibleForFullVersion = isFullVersion()
let hasCancelledFullVersion: Bool
let hasCancelledTrustedNetworks: Bool
#if os(iOS)
hasCancelledFullVersion = !isEligibleForFullVersion && (isCancelledPurchase(.fullVersion) || isCancelledPurchase(.fullVersion_iOS))
hasCancelledTrustedNetworks = !isEligibleForFullVersion && isCancelledPurchase(.trustedNetworks)
#else
hasCancelledFullVersion = !isEligibleForFullVersion && (isCancelledPurchase(.fullVersion) || isCancelledPurchase(.fullVersion_macOS))
hasCancelledTrustedNetworks = false
#endif
// review features and potentially revert them if they were used (Siri is handled in AppDelegate)
return hasCancelledFullVersion || hasCancelledTrustedNetworks
}
}