screen id is added to checkout initiated and post subscriptions

Author: ren6

ApphudSDK.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name             = 'ApphudSDK'
-  s.version          = '4.0.0-beta5'
+  s.version          = '4.0.0'
   s.summary          = 'Build and Measure In-App Subscriptions on iOS.'
   s.description      = 'Apphud covers every aspect when it comes to In-App Subscriptions from integration to analytics on iOS and Android.'
   s.homepage         = 'https://github.com/apphud/ApphudSDK'

Examples/ApphudDemoSwift/ApphudSDKDemo/AppDelegate.swift

@@ -24,7 +24,7 @@ class AppDelegate: UIResponder, UIApplicationDelegate, @preconcurrency UNUserNot
 
         Apphud.start(apiKey: "YOUR_API_KEY")
         Apphud.setDeviceIdentifiers(idfa: nil, idfv: UIDevice.current.identifierForVendor?.uuidString)
-        fetchIDFA()
+//        fetchIDFA()
 
         Apphud.preloadPaywallScreens(placementIdentifiers: ["MY_PLAYWALL_PLACEMENT_ID", "ANOTHER_PLACEMENT_ID"])
 
@@ -35,7 +35,7 @@ class AppDelegate: UIResponder, UIApplicationDelegate, @preconcurrency UNUserNot
         Apphud.incrementUserProperty(key: .init("coins_count"), by: 2)
 //        Apphud.setDelegate(self)
         Apphud.setUIDelegate(self)
-        registerForNotifications()
+//        registerForNotifications()
 
         return true
     }

Sources/ApphudUI/ApphudPaywallScreenController+I.swift

@@ -164,8 +164,8 @@ extension ApphudPaywallScreenController: WKUIDelegate {
         if self.useSystemLoadingIndicator {
             showLoadingIndicator()
         }
-
-        Apphud.purchase(product) { [weak self] result in
+        
+        ApphudInternal.shared.purchase(productId: product.productId, product: product, validate: true, purchasingFromScreen: true) { [weak self] result in
             if let self {
                 self.hideLoadingIndicator()
                 self.onTransactionCompleted?(result)

Sources/ApphudUI/ApphudScreenController.swift

@@ -273,7 +273,7 @@ class ApphudScreenController: UIViewController {
 
                     ApphudInternal.shared.uiDelegate?.apphudWillPurchase?(product: product, offerID: offerID!, screenName: self.rule.screen_name)
 
-                    ApphudInternal.shared.purchasePromo(skProduct: product, apphudProduct: nil, discountID: offerID!) { (result) in
+                    ApphudInternal.shared.purchasePromo(skProduct: product, apphudProduct: nil, discountID: offerID!, fromScreen: true) { (result) in
                         self.handlePurchaseResult(product: product, offerID: offerID!, result: result)
                     }
                 } else {
@@ -287,7 +287,7 @@ class ApphudScreenController: UIViewController {
 
             ApphudInternal.shared.uiDelegate?.apphudWillPurchase?(product: product, offerID: nil, screenName: self.rule.screen_name)
 
-            ApphudInternal.shared.purchase(productId: product.productIdentifier, product: nil, validate: true) { result in
+            ApphudInternal.shared.purchase(productId: product.productIdentifier, product: nil, validate: true, purchasingFromScreen: true) { result in
                 self.handlePurchaseResult(product: product, result: result)
             }
         }

Sources/Internal/ApphudAsyncStoreKit.swift

@@ -90,7 +90,7 @@ internal class ApphudAsyncStoreKit {
 
         do {
 
-            ApphudLoggerService.shared.paywallCheckoutInitiated(apphudProduct: apphudProduct, productId: product.id)
+            ApphudLoggerService.shared.paywallCheckoutInitiated(apphudProduct: apphudProduct, productId: product.id, screenId: nil)
             #if os(iOS) || os(tvOS) || os(macOS) || os(watchOS)
             let result = try await product.purchase(options: options)
             #else

Sources/Internal/ApphudInternal+Eligibility.swift

@@ -31,7 +31,7 @@ extension ApphudInternal {
             } else if self.currentUser?.subscriptions.count ?? 0 == 0 && !UserDefaults.standard.bool(forKey: didSendReceiptForPromoEligibility) {
                 if let receiptString = apphudReceiptDataString() {
                     apphudLog("Restoring subscriptions for promo eligibility check")
-                    self.submitReceipt(product: nil, apphudProduct: nil, transaction: nil, receiptString: receiptString, notifyDelegate: true, eligibilityCheck: true, callback: { _ in
+                    self.submitReceipt(product: nil, apphudProduct: nil, transaction: nil, receiptString: receiptString, notifyDelegate: true, eligibilityCheck: true, fromScreen: false, callback: { _ in
                         UserDefaults.standard.set(true, forKey: didSendReceiptForPromoEligibility)
                         Task {
                             let response = await self._checkPromoEligibilitiesForRegisteredUser(products: products)
@@ -106,7 +106,7 @@ extension ApphudInternal {
             } else if self.currentUser?.subscriptions.count ?? 0 == 0 && !UserDefaults.standard.bool(forKey: didSendReceiptForIntroEligibility) {
                 if let receiptString = apphudReceiptDataString() {
                     apphudLog("Restoring subscriptions for intro eligibility check")
-                    self.submitReceipt(product: nil, apphudProduct: nil, transaction: nil, receiptString: receiptString, notifyDelegate: true, eligibilityCheck: true, callback: { _ in
+                    self.submitReceipt(product: nil, apphudProduct: nil, transaction: nil, receiptString: receiptString, notifyDelegate: true, eligibilityCheck: true, fromScreen: false, callback: { _ in
                         UserDefaults.standard.set(true, forKey: didSendReceiptForIntroEligibility)
                         Task {
                             let response = await self._checkIntroEligibilitiesForRegisteredUser(products: products)

Sources/Internal/ApphudInternal+Purchase.swift

@@ -116,7 +116,8 @@ extension ApphudInternal {
                                            transactionProductIdentifier: productID,
                                            transactionState: isRecentlyPurchased ? .purchased : nil,
                                            receiptString: receipt,
-                                                 notifyDelegate: true) { _ in
+                                                 notifyDelegate: true,
+                                                 fromScreen: false) { _ in
                             continuation.resume(returning: true)
                         }
                     }
@@ -166,7 +167,7 @@ extension ApphudInternal {
                 apphudLog("App Store receipt is missing, but got transaction. Will try to submit transaction instead..", forceDisplay: true)
             }
 
-            self.submitReceipt(product: nil, apphudProduct: nil, transaction: transaction, receiptString: receiptString, notifyDelegate: true, eligibilityCheck: true, callback: { error in
+            self.submitReceipt(product: nil, apphudProduct: nil, transaction: transaction, receiptString: receiptString, notifyDelegate: true, eligibilityCheck: true, fromScreen: false, callback: { error in
                 let result = self.purchaseResult(productId: transaction.payment.productIdentifier, transaction: transaction, error: error)
                 callback(result)
             })
@@ -199,18 +200,18 @@ extension ApphudInternal {
 
         performWhenUserRegistered {
 
-            self.submitReceipt(product: nil, apphudProduct: nil, transaction: transaction, receiptString: receiptString, notifyDelegate: true) { error in
+            self.submitReceipt(product: nil, apphudProduct: nil, transaction: transaction, receiptString: receiptString, notifyDelegate: true, fromScreen: false) { error in
                 self.restorePurchasesCallback?(self.currentUser?.subscriptions, self.currentUser?.purchases, error)
                 self.restorePurchasesCallback = nil
             }
         }
     }
 
-    internal func submitReceipt(product: SKProduct, transaction: SKPaymentTransaction?, apphudProduct: ApphudProduct? = nil, callback: ((ApphudPurchaseResult) -> Void)?) {
+    internal func submitReceipt(product: SKProduct, transaction: SKPaymentTransaction?, apphudProduct: ApphudProduct? = nil, fromScreen: Bool, callback: ((ApphudPurchaseResult) -> Void)?) {
 
         let block: (String?) -> Void = { receiptStr in
             if transaction != nil {
-                self.submitReceipt(product: product, apphudProduct: apphudProduct, transaction: transaction, receiptString: receiptStr, notifyDelegate: true) { error in
+                self.submitReceipt(product: product, apphudProduct: apphudProduct, transaction: transaction, receiptString: receiptStr, notifyDelegate: true, fromScreen: fromScreen) { error in
                     Task { @MainActor in
                         let result = self.purchaseResult(productId: product.productIdentifier, transaction: transaction, error: error)
                         callback?(result)
@@ -242,7 +243,7 @@ extension ApphudInternal {
         }
     }
 
-    internal func submitReceipt(product: SKProduct?, apphudProduct: ApphudProduct?, transaction: SKPaymentTransaction?, receiptString: String?, notifyDelegate: Bool, eligibilityCheck: Bool = false, callback: ApphudNSErrorCallback?) {
+    internal func submitReceipt(product: SKProduct?, apphudProduct: ApphudProduct?, transaction: SKPaymentTransaction?, receiptString: String?, notifyDelegate: Bool, eligibilityCheck: Bool = false, fromScreen: Bool, callback: ApphudNSErrorCallback?) {
 
         let productId = product?.productIdentifier ?? transaction?.payment.productIdentifier
         let finalProduct = product ?? ApphudStoreKitWrapper.shared.products.first(where: { $0.productIdentifier == productId })
@@ -257,6 +258,7 @@ extension ApphudInternal {
                                    receiptString: receiptString,
                                    notifyDelegate: notifyDelegate,
                                    eligibilityCheck: eligibilityCheck,
+                                   fromScreen: fromScreen,
                                    callback: callback)
             }
         }
@@ -278,6 +280,7 @@ extension ApphudInternal {
                                 receiptString: String?,
                                 notifyDelegate: Bool,
                                 eligibilityCheck: Bool = false,
+                                fromScreen: Bool,
                                 callback: ApphudNSErrorCallback?) async {
 
         await MainActor.run {
@@ -322,6 +325,11 @@ extension ApphudInternal {
         }
 
         if hasMadePurchase, let purchasedApphudProduct = apphudProduct ?? purchasingProduct, purchasedApphudProduct.productId == transactionProductIdentifier {
+            
+            if fromScreen {
+                params["screen_id"] = purchasedApphudProduct.paywall?.screen?.id
+            }
+            
             params["product_bundle_id"] = purchasedApphudProduct.id
             params["paywall_id"] = purchasedApphudProduct.paywallId
             params["placement_id"] = purchasedApphudProduct.placementId
@@ -445,27 +453,27 @@ extension ApphudInternal {
 
     @MainActor
     @available(iOS 13.0.0, macOS 11.0, watchOS 6.0, tvOS 13.0, *)
-    internal func purchase(productId: String, product: ApphudProduct?, validate: Bool, isPurchasing: Binding<Bool>? = nil, value: Double? = nil) async -> ApphudPurchaseResult {
+    internal func purchase(productId: String, product: ApphudProduct?, validate: Bool, isPurchasing: Binding<Bool>? = nil, fromScreen: Bool, value: Double? = nil) async -> ApphudPurchaseResult {
         await withUnsafeContinuation { continuation in
             isPurchasing?.wrappedValue = true
-            purchase(productId: productId, product: product, validate: validate, callback: { result in
+            purchase(productId: productId, product: product, validate: validate, purchasingFromScreen: fromScreen, callback: { result in
                 isPurchasing?.wrappedValue = false
                 continuation.resume(returning: result)
             })
         }
     }
 
-    @MainActor internal func purchase(productId: String, product: ApphudProduct?, validate: Bool, value: Double? = nil, callback: ((ApphudPurchaseResult) -> Void)?) {
-
+    @MainActor internal func purchase(productId: String, product: ApphudProduct?, validate: Bool, purchasingFromScreen: Bool, value: Double? = nil, callback: ((ApphudPurchaseResult) -> Void)?) {
+        
         let skProduct = product?.skProduct ?? ApphudStoreKitWrapper.shared.products.first(where: { $0.productIdentifier == productId })
 
         if let skProduct = skProduct {
-            purchase(product: skProduct, apphudProduct: product, validate: validate, value: value, callback: callback)
+            purchase(product: skProduct, apphudProduct: product, validate: validate, fromScreen: purchasingFromScreen, value: value, callback: callback)
         } else {
             apphudLog("Product with id \(productId) not found, re-fetching from App Store...")
             ApphudStoreKitWrapper.shared.fetchProducts(productIds: [productId]) { prds in
                 if let sk = prds?.first(where: { $0.productIdentifier == productId }) {
-                    self.purchase(product: sk, apphudProduct: product, validate: validate, value: value, callback: callback)
+                    self.purchase(product: sk, apphudProduct: product, validate: validate, fromScreen: purchasingFromScreen, value: value, callback: callback)
                 } else {
                     let message = "Unable to start payment because product identifier is invalid: [\([productId])]"
                     apphudLog(message, forceDisplay: true)
@@ -476,12 +484,12 @@ extension ApphudInternal {
         }
     }
 
-    internal func purchasePromo(skProduct: SKProduct?, apphudProduct: ApphudProduct?, discountID: String, callback: ((ApphudPurchaseResult) -> Void)?) {
+    internal func purchasePromo(skProduct: SKProduct?, apphudProduct: ApphudProduct?, discountID: String, fromScreen: Bool, callback: ((ApphudPurchaseResult) -> Void)?) {
 
         let skCallback: ((SKProduct) -> Void) = { skProduct in
             self.signPromoOffer(productID: skProduct.productIdentifier, discountID: discountID) { (paymentDiscount, _) in
                 if let paymentDiscount = paymentDiscount {
-                    self.purchasePromo(skProduct: skProduct, product: apphudProduct, discount: paymentDiscount, callback: callback)
+                    self.purchasePromo(skProduct: skProduct, product: apphudProduct, discount: paymentDiscount, fromScreen: fromScreen, callback: callback)
                 } else {
                     callback?(ApphudPurchaseResult(nil, nil, nil, ApphudError(message: "Could not sign offer id: \(discountID), product id: \(skProduct.productIdentifier)")))
                 }
@@ -504,8 +512,11 @@ extension ApphudInternal {
 
     // MARK: - Private purchase methods
 
-    private func purchase(product: SKProduct, apphudProduct: ApphudProduct?, validate: Bool, value: Double? = nil, callback: ((ApphudPurchaseResult) -> Void)?) {
-        ApphudLoggerService.shared.paywallCheckoutInitiated(apphudProduct: apphudProduct, productId: product.productIdentifier)
+    private func purchase(product: SKProduct, apphudProduct: ApphudProduct?, validate: Bool, fromScreen: Bool, value: Double? = nil, callback: ((ApphudPurchaseResult) -> Void)?) {
+        
+        let screenId = fromScreen ? apphudProduct?.paywall?.screen?.id : nil
+        
+        ApphudLoggerService.shared.paywallCheckoutInitiated(apphudProduct: apphudProduct, productId: product.productIdentifier, screenId: screenId)
 
         purchasingProduct = apphudProduct
 
@@ -517,16 +528,16 @@ extension ApphudInternal {
 
             Task { @MainActor in
                 if validate {
-                    self.handleTransaction(product: product, transaction: transaction, error: error, apphudProduct: apphudProduct, callback: callback)
+                    self.handleTransaction(product: product, transaction: transaction, error: error, apphudProduct: apphudProduct, fromScreen: fromScreen, callback: callback)
                 } else {
-                    self.handleTransaction(product: product, transaction: transaction, error: error, apphudProduct: apphudProduct, callback: nil)
+                    self.handleTransaction(product: product, transaction: transaction, error: error, apphudProduct: apphudProduct, fromScreen: fromScreen, callback: nil)
                     callback?(ApphudPurchaseResult(nil, nil, transaction, error))
                 }
             }
         }
     }
 
-    private func purchasePromo(skProduct: SKProduct, product: ApphudProduct?, discount: SKPaymentDiscount, callback: ((ApphudPurchaseResult) -> Void)?) {
+    private func purchasePromo(skProduct: SKProduct, product: ApphudProduct?, discount: SKPaymentDiscount, fromScreen: Bool, callback: ((ApphudPurchaseResult) -> Void)?) {
 
         purchasingProduct = product
 
@@ -536,7 +547,7 @@ extension ApphudInternal {
             }
 
             Task { @MainActor in
-                self.handleTransaction(product: skProduct, transaction: transaction, error: error, apphudProduct: product, callback: callback)
+                self.handleTransaction(product: skProduct, transaction: transaction, error: error, apphudProduct: product, fromScreen: fromScreen, callback: callback)
             }
         }
     }
@@ -545,9 +556,9 @@ extension ApphudInternal {
         observerModePurchaseIdentifiers = (paywallId, placementId)
     }
 
-    @MainActor private func handleTransaction(product: SKProduct, transaction: SKPaymentTransaction, error: Error?, apphudProduct: ApphudProduct?, callback: ((ApphudPurchaseResult) -> Void)?) {
+    @MainActor private func handleTransaction(product: SKProduct, transaction: SKPaymentTransaction, error: Error?, apphudProduct: ApphudProduct?, fromScreen: Bool, callback: ((ApphudPurchaseResult) -> Void)?) {
         if transaction.transactionState == .purchased || transaction.failedWithUnknownReason {
-            self.submitReceipt(product: product, transaction: transaction, apphudProduct: apphudProduct) { (result) in
+            self.submitReceipt(product: product, transaction: transaction, apphudProduct: apphudProduct, fromScreen: fromScreen) { (result) in
                 ApphudStoreKitWrapper.shared.finishTransaction(transaction)
                 callback?(result)
             }

Sources/Internal/ApphudInternal.swift

@@ -184,6 +184,7 @@ final class ApphudInternal: NSObject {
     internal var didHandleBecomeActive = false
     internal var respondedStoreKitProducts = false
 
+    internal var purchasingFromScreen: Bool = false
     internal var purchasingProduct: ApphudProduct?
     internal var pendingTransactionID: String?
     internal var fallbackMode = false

Sources/Internal/ApphudLoggerService.swift

@@ -44,8 +44,8 @@ class ApphudLoggerService {
         ApphudInternal.shared.trackPaywallEvent(params: ["name": "paywall_closed", "properties": ["paywall_id": paywallId, "placement_id": placementId].compactMapValues { $0 }])
     }
 
-    internal func paywallCheckoutInitiated(apphudProduct: ApphudProduct?, productId: String?) {
-        ApphudInternal.shared.trackPaywallEvent(params: ["name": "paywall_checkout_initiated", "properties": ["paywall_id": apphudProduct?.paywallId, "placement_id": apphudProduct?.placementId, "product_id": productId, "variation_identifier": apphudProduct?.variationIdentifier, "experiment_id": apphudProduct?.experimentId].compactMapValues { $0 } ])
+    internal func paywallCheckoutInitiated(apphudProduct: ApphudProduct?, productId: String?, screenId: String?) {
+        ApphudInternal.shared.trackPaywallEvent(params: ["name": "paywall_checkout_initiated", "properties": ["paywall_id": apphudProduct?.paywallId, "placement_id": apphudProduct?.placementId, "product_id": productId, "variation_identifier": apphudProduct?.variationIdentifier, "screen_id": screenId , "experiment_id": apphudProduct?.experimentId].compactMapValues { $0 } ])
     }
 
     @available(iOS 15.0, macOS 12.0, tvOS 15.0, watchOS 8.0, *)

Sources/Internal/ApphudStoreKitWrapper.swift

@@ -312,7 +312,7 @@ internal class ApphudStoreKitWrapper: NSObject, SKPaymentTransactionObserver, SK
 
         DispatchQueue.main.async {
             if let callback = ApphudInternal.shared.delegate?.apphudShouldStartAppStoreDirectPurchase(product) {
-                ApphudInternal.shared.purchase(productId: product.productIdentifier, product: nil, validate: true, callback: callback)
+                ApphudInternal.shared.purchase(productId: product.productIdentifier, product: nil, validate: true, purchasingFromScreen: false, callback: callback)
             }
         }