Using Multiple Managers - Encore

Overview

When more than one subscription manager is live in your app, two things need a decision that a single-manager setup makes for you: which manager performs a given purchase, and how you combine each manager’s entitlement state with Encore’s grants. The rest of Add Subscription Product is unchanged.

Each product still needs registering in the manager that sells it, and attaching to that manager’s entitlement, before the state merged below turns true: RevenueCat, Superwall, Adapty, Qonversion.

Route the purchase

Branch inside your EncorePurchaseController on the product id Encore hands you:

final class AppPurchases: EncorePurchaseController {
    func purchase(_ request: PurchaseRequest) async throws -> EncorePurchaseResult {
        if request.productId.hasPrefix("rc_") {
            let products = try await Purchases.shared.products([request.productId])
            guard let product = products.first else { throw PurchaseError.notFound }
            let result = try await Purchases.shared.purchase(product: product)
            return result.userCancelled ? .cancelled : .purchased
        }

        guard let product = try await Product.products(for: [request.productId]).first else {
            throw PurchaseError.notFound
        }
        switch try await product.purchase() {
        case .success(let verification):
            if case .verified(let transaction) = verification { await transaction.finish() }
            return .purchased
        case .userCancelled: return .cancelled
        case .pending: return .pending
        @unknown default: return .cancelled
        }
    }
}

Encore.shared.configure(apiKey: "pk_live_your_key", purchaseController: AppPurchases())

Merge the entitlement state

Each manager publishes its own subscription state, and Encore publishes its grants through isActivePublisher(). Combine them into the single flag your UI gates on:

import Combine
import Encore
import RevenueCat
import SuperwallKit

@MainActor
final class EntitlementManager: ObservableObject {
    @Published var hasProAccess = false

    private var cancellables = Set<AnyCancellable>()
    private let revenueCatActive = CurrentValueSubject<Bool, Never>(false)

    init() {
        Purchases.shared.delegate = self

        Publishers.CombineLatest3(
            revenueCatActive.eraseToAnyPublisher(),
            Superwall.shared.$subscriptionStatus,
            Encore.shared.isActivePublisher(for: .freeTrial())
        )
        .map { revenueCat, superwall, encore in
            revenueCat || superwall != .inactive || encore
        }
        .assign(to: \.hasProAccess, on: self)
        .store(in: &cancellables)
    }
}

extension EntitlementManager: PurchasesDelegate {
    nonisolated func purchases(_ purchases: Purchases, receivedUpdated customerInfo: CustomerInfo) {
        Task { @MainActor in
            revenueCatActive.send(!customerInfo.entitlements.active.isEmpty)
        }
    }
}

Full contracts: isActivePublisher() · isActive() · EntitlementScope.