AdServices

Sources/Attribution/AttributionFetcher.swift

@@ -19,10 +19,16 @@ import UIKit
 import WatchKit
 #endif
 
+#if canImport(AdServices)
+import AdServices
+#endif
+
 enum AttributionFetcherError: Error {
 
     case identifierForAdvertiserUnavailableForPlatform
     case identifierForAdvertiserFrameworksUnavailable
+    case adServicesNotAvailable
+    case adServicesTokenFetchError
 
 }
 
@@ -82,6 +88,23 @@ class AttributionFetcher {
 #endif
     }
 
+    // should match OS availability in https://developer.apple.com/documentation/ad_services
+    @available(iOS 14.3, macOS 11.1, macCatalyst 14.3, *)
+    var adServicesToken: String? {
+#if canImport(AdServices)
+        do {
+            return try AAAttribution.attributionToken()
+        } catch {
+            let message = Strings.attribution.adservices_token_fetch_failed(error: error)
+            Logger.appleWarning(message)
+            return nil
+        }
+#else
+        Logger.warn(Strings.attribution.adservices_not_supported)
+        return nil
+#endif
+    }
+
     var isAuthorizedToPostSearchAds: Bool {
         // Should match platforms that require permissions detailed in
         // https://developer.apple.com/app-store/user-privacy-and-data-use/

Sources/Attribution/AttributionNetwork.swift

@@ -22,37 +22,43 @@ import Foundation
     /**
      Apple's search ads
      */
-    case appleSearchAds
+    @available(*, deprecated, message: "use adServices")
+    case appleSearchAds = 0
 
     /**
      Adjust https://www.adjust.com/
      */
-    case adjust
+    case adjust = 1
 
     /**
      AppsFlyer https://www.appsflyer.com/
      */
-    case appsFlyer
+    case appsFlyer = 2
 
     /**
      Branch https://www.branch.io/
      */
-    case branch
+    case branch = 3
 
     /**
      Tenjin https://www.tenjin.io/
      */
-    case tenjin
+    case tenjin = 4
 
     /**
      Facebook https://developers.facebook.com/
      */
-    case facebook
+    case facebook = 5
 
     /**
     mParticle https://www.mparticle.com/
     */
-    case mParticle
+    case mParticle = 6
+
+    /**
+     AdServices token
+     */
+    case adServices = 7
 
 }
 
@@ -64,3 +70,14 @@ extension AttributionNetwork: Encodable {
     }
 
 }
+
+extension AttributionNetwork {
+
+    var isAppleSearchAdds: Bool {
+        switch self {
+        case .appleSearchAds: return true
+        default: return false
+        }
+    }
+
+}

Sources/Attribution/AttributionPoster.swift

@@ -35,7 +35,6 @@ class AttributionPoster {
         self.subscriberAttributesManager = subscriberAttributesManager
     }
 
-    // swiftlint:disable:next function_body_length
     func post(attributionData data: [String: Any],
               fromNetwork network: AttributionNetwork,
               networkUserId: String?) {
@@ -54,19 +53,13 @@ class AttributionPoster {
         }
 
         let currentAppUserID = self.currentUserProvider.currentAppUserID
-        let networkKey = String(network.rawValue)
-        let latestNetworkIdsAndAdvertisingIdsSentByNetwork =
-            deviceCache.latestNetworkAndAdvertisingIdsSent(appUserID: currentAppUserID)
-        let latestSentToNetwork = latestNetworkIdsAndAdvertisingIdsSentByNetwork[networkKey]
-
-        let newValueForNetwork = "\(identifierForAdvertisers ?? "(null)")_\(networkUserId ?? "(null)")"
-        guard latestSentToNetwork != newValueForNetwork else {
-            Logger.debug(Strings.attribution.skip_same_attributes)
+        guard let newDictToCache = self.getNewDictToCache(currentAppUserID: currentAppUserID,
+                                                          idfa: identifierForAdvertisers,
+                                                          network: network,
+                                                          networkUserId: networkUserId) else {
             return
         }
 
-        var newDictToCache = latestNetworkIdsAndAdvertisingIdsSentByNetwork
-        newDictToCache[networkKey] = newValueForNetwork
         var newData = data
 
         if let identifierForAdvertisers = identifierForAdvertisers {
@@ -88,7 +81,7 @@ class AttributionPoster {
         }
 
         if !newData.isEmpty {
-            if network == .appleSearchAds {
+            if network.isAppleSearchAdds {
                 postSearchAds(newData: newData,
                               network: network,
                               appUserID: currentAppUserID,
@@ -102,13 +95,13 @@ class AttributionPoster {
         }
     }
 
+    @available(*, deprecated)
     func postAppleSearchAdsAttributionIfNeeded() {
         guard attributionFetcher.isAuthorizedToPostSearchAds else {
             return
         }
 
-        let latestIdsSent = latestNetworkIdAndAdvertisingIdentifierSent(network: .appleSearchAds)
-        guard latestIdsSent == nil else {
+        guard self.latestNetworkIdAndAdvertisingIdentifierSent(network: .appleSearchAds) == nil else {
             return
         }
 
@@ -130,6 +123,23 @@ class AttributionPoster {
         }
     }
 
+    // should match OS availability in https://developer.apple.com/documentation/ad_services
+    @available(iOS 14.3, macOS 11.1, macCatalyst 14.3, *)
+    @available(tvOS, unavailable)
+    @available(watchOS, unavailable)
+    func postAdServicesTokenIfNeeded() {
+        let latestTokenSent = latestNetworkIdAndAdvertisingIdentifierSent(network: .adServices)
+        guard latestTokenSent == nil else {
+            return
+        }
+
+        guard let attributionToken = attributionFetcher.adServicesToken else {
+            return
+        }
+
+        self.post(adServicesToken: attributionToken)
+    }
+
     func postPostponedAttributionDataIfNeeded() {
         guard let postponedAttributionData = Self.postponedAttributionData else {
             return
@@ -154,35 +164,74 @@ class AttributionPoster {
         postponedAttributionData = postponedData
     }
 
+    private func post(adServicesToken: String) {
+        let currentAppUserID = self.currentUserProvider.currentAppUserID
+
+        // set the cache in advance to avoid multiple post calls
+        var newDictToCache = self.deviceCache.latestAdvertisingIdsByNetworkSent(appUserID: currentAppUserID)
+        newDictToCache[AttributionNetwork.adServices] = adServicesToken
+        self.deviceCache.set(latestAdvertisingIdsByNetworkSent: newDictToCache, appUserID: currentAppUserID)
+
+         backend.post(adServicesToken: adServicesToken, appUserID: currentAppUserID) { error in
+             guard let error = error else {
+                 Logger.debug(Strings.attribution.adservices_token_post_succeeded)
+                 return
+             }
+             Logger.warn(Strings.attribution.adservices_token_post_failed(error: error))
+
+            // if there's an error, reset the cache
+            newDictToCache[AttributionNetwork.adServices] = nil
+            self.deviceCache.set(latestAdvertisingIdsByNetworkSent: newDictToCache, appUserID: currentAppUserID)
+        }
+    }
+
     private func latestNetworkIdAndAdvertisingIdentifierSent(network: AttributionNetwork) -> String? {
-        let networkID = String(network.rawValue)
-        let cachedDict = deviceCache.latestNetworkAndAdvertisingIdsSent(
+        let cachedDict = deviceCache.latestAdvertisingIdsByNetworkSent(
             appUserID: self.currentUserProvider.currentAppUserID
         )
-        return cachedDict[networkID]
+        return cachedDict[network]
     }
 
     private func postSearchAds(newData: [String: Any],
                                network: AttributionNetwork,
                                appUserID: String,
-                               newDictToCache: [String: String]) {
+                               newDictToCache: [AttributionNetwork: String]) {
         backend.post(attributionData: newData, network: network, appUserID: appUserID) { error in
             guard error == nil else {
                 return
             }
 
-            self.deviceCache.set(latestNetworkAndAdvertisingIdsSent: newDictToCache, appUserID: appUserID)
+            self.deviceCache.set(latestAdvertisingIdsByNetworkSent: newDictToCache, appUserID: appUserID)
         }
     }
 
     private func postSubscriberAttributes(newData: [String: Any],
                                           network: AttributionNetwork,
                                           appUserID: String,
-                                          newDictToCache: [String: String]) {
+                                          newDictToCache: [AttributionNetwork: String]) {
         subscriberAttributesManager.setAttributes(fromAttributionData: newData,
                                                   network: network,
                                                   appUserID: appUserID)
-        deviceCache.set(latestNetworkAndAdvertisingIdsSent: newDictToCache, appUserID: appUserID)
+        deviceCache.set(latestAdvertisingIdsByNetworkSent: newDictToCache, appUserID: appUserID)
+    }
+
+    private func getNewDictToCache(currentAppUserID: String,
+                                   idfa: String?,
+                                   network: AttributionNetwork,
+                                   networkUserId: String?) -> [AttributionNetwork: String]? {
+        let latestAdvertisingIdsByNetworkSent =
+            deviceCache.latestAdvertisingIdsByNetworkSent(appUserID: currentAppUserID)
+        let latestSentToNetwork = latestAdvertisingIdsByNetworkSent[network]
+
+        let newValueForNetwork = "\(idfa ?? "(null)")_\(networkUserId ?? "(null)")"
+        guard latestSentToNetwork != newValueForNetwork else {
+            Logger.debug(Strings.attribution.skip_same_attributes)
+            return nil
+        }
+
+        var newDictToCache = latestAdvertisingIdsByNetworkSent
+        newDictToCache[network] = newValueForNetwork
+        return newDictToCache
     }
 
 }

Sources/Caching/DeviceCache.swift

@@ -274,17 +274,33 @@ class DeviceCache {
 
     // MARK: - attribution
 
-    func latestNetworkAndAdvertisingIdsSent(appUserID: String) -> [String: String] {
+    func latestAdvertisingIdsByNetworkSent(appUserID: String) -> [AttributionNetwork: String] {
         return self.userDefaults.read {
             let key = CacheKeyBases.attributionDataDefaults + appUserID
-            let latestNetworkAndAdvertisingIdsSent = $0.object(forKey: key) as? [String: String] ?? [:]
-            return latestNetworkAndAdvertisingIdsSent
+            let latestAdvertisingIdsByRawNetworkSent = $0.object(forKey: key) as? [String: String] ?? [:]
+
+            let latestSent: [AttributionNetwork: String] =
+                 latestAdvertisingIdsByRawNetworkSent.compactMapKeys { networkKey in
+                     guard let networkRawValue = Int(networkKey),
+                        let attributionNetwork = AttributionNetwork(rawValue: networkRawValue) else {
+                            Logger.error(
+                                Strings.attribution.latest_attribution_sent_user_defaults_invalid(
+                                    networkKey: networkKey
+                                )
+                            )
+                             return nil
+                        }
+                        return attributionNetwork
+                    }
+
+            return latestSent
         }
     }
 
-    func set(latestNetworkAndAdvertisingIdsSent: [String: String], appUserID: String) {
+    func set(latestAdvertisingIdsByNetworkSent: [AttributionNetwork: String], appUserID: String) {
         self.userDefaults.write {
-            $0.setValue(latestNetworkAndAdvertisingIdsSent,
+            let latestAdIdsByRawNetworkStringSent = latestAdvertisingIdsByNetworkSent.mapKeys { String($0.rawValue) }
+            $0.setValue(latestAdIdsByRawNetworkStringSent,
                         forKey: CacheKeyBases.attributionDataDefaults + appUserID)
         }
     }

Sources/DocCDocumentation/DocCDocumentation.docc/Purchases.md

@@ -106,7 +106,6 @@ Most features require configuring the SDK before using it.
 - ``Purchases/finishTransactions``
 - ``Purchases/invalidateCustomerInfoCache()``
 - ``Purchases/forceUniversalAppStore``
-- ``Purchases/automaticAppleSearchAdsAttributionCollection``
 - ``Purchases/proxyURL``
 - ``Purchases/verboseLogs``
 - ``Purchases/verboseLogHandler``

Sources/Logging/Strings/AttributionStrings.swift

@@ -38,7 +38,11 @@ enum AttributionStrings {
     case unsynced_attributes(unsyncedAttributes: SubscriberAttribute.Dictionary)
     case attribute_set_locally(attribute: String)
     case missing_advertiser_identifiers
-    case unknown_sk2_product_discount_type(rawValue: String)
+    case adservices_not_supported
+    case adservices_token_fetch_failed(error: Error)
+    case adservices_token_post_failed(error: BackendError)
+    case adservices_token_post_succeeded
+    case latest_attribution_sent_user_defaults_invalid(networkKey: String)
 
 }
 
@@ -115,8 +119,21 @@ extension AttributionStrings: CustomStringConvertible {
         case .missing_advertiser_identifiers:
             return "Attribution error: identifierForAdvertisers is missing"
 
-        case .unknown_sk2_product_discount_type(let rawValue):
-            return "Failed to create StoreProductDiscount.DiscountType with unknown value: \(rawValue)"
+        case .adservices_not_supported:
+            return "Tried to fetch AdServices attribution token on device without " +
+                "AdServices support."
+
+        case .adservices_token_fetch_failed(let error):
+            return "Fetching AdServices attribution token failed with error: \(error.localizedDescription)"
+
+        case .adservices_token_post_failed(let error):
+            return "Posting AdServices attribution token failed with error: \(error.localizedDescription)"
+
+        case .adservices_token_post_succeeded:
+            return "AdServices attribution token successfully posted"
+
+        case .latest_attribution_sent_user_defaults_invalid(let networkKey):
+            return "Attribution data stored in UserDefaults has invalid format for network key: \(networkKey)"
 
         }
     }

Sources/Logging/Strings/StoreKitStrings.swift

@@ -34,6 +34,8 @@ enum StoreKitStrings {
 
     case sk1_no_known_product_type
 
+    case unknown_sk2_product_discount_type(rawValue: String)
+
     case sk1_discount_missing_locale
 
     case no_cached_products_starting_store_products_request(identifiers: Set<String>)
@@ -76,6 +78,9 @@ extension StoreKitStrings: CustomStringConvertible {
             return "This StoreProduct represents an SK1 product, the type of product cannot be determined, " +
             "the value will be undefined. Use `StoreProduct.productCategory` instead."
 
+        case .unknown_sk2_product_discount_type(let rawValue):
+            return "Failed to create StoreProductDiscount.DiscountType with unknown value: \(rawValue)"
+
         case .sk1_discount_missing_locale:
             return "There is an issue with the App Store, this SKProductDiscount is missing a Locale - " +
             "The current device Locale will be used instead."

Sources/Misc/Deprecations.swift

@@ -144,6 +144,12 @@ public extension Purchases {
         )
     }
 
+    /**
+     * Enable automatic collection of Apple Search Ads attribution. Defaults to `false`.
+     */
+    @available(*, deprecated, message: "Use Purchases.shared.attribution.enableAdServicesAttributionTokenCollection() instead")
+    @objc static var automaticAppleSearchAdsAttributionCollection: Bool = false
+
 }
 
 public extension Purchases {