Cómo añadir compras integradas en una aplicación en SwiftUI

import Foundation
import StoreKit

// Alias para simplificar
typealias Transaction = StoreKit.Transaction
typealias RenewalInfo = StoreKit.Product.SubscriptionInfo.RenewalInfo
typealias RenewalState = StoreKit.Product.SubscriptionInfo.RenewalState

public enum StoreError: Error {
    case failedVerification
}

@MainActor
class StoreManager: ObservableObject {
    
    // Los productos disponibles para comprar
    @Published private(set) var products: [Product] = []
    
    // Estado de si el usuario ha comprado la versión Pro
    @Published private(set) var hasUnlockedPro: Bool = false
    
    // Los IDs de tus productos (deben coincidir con App Store Connect y .storekit)
    private let productIds: [String] = ["com.tuempresa.tuapp.premium_lifetime"]
    
    // Tarea para escuchar actualizaciones de transacciones en segundo plano
    var updateListenerTask: Task<Void, Error>? = nil

    init() {
        // Al iniciar, empezamos a escuchar transacciones
        updateListenerTask = listenForTransactions()
        
        // Iniciamos la carga de productos y verificamos compras previas
        Task {
            await requestProducts()
            await updateCustomerProductStatus()
        }
    }
    
    deinit {
        updateListenerTask?.cancel()
    }
    
    // MARK: - 1. Obtener Productos
    func requestProducts() async {
        do {
            // Llamada asíncrona a Apple para obtener detalles (precio, moneda, etc.)
            let products = try await Product.products(for: productIds)
            self.products = products.sorted(by: { $0.price < $1.price })
        } catch {
            print("Error al obtener productos: \(error)")
        }
    }
    
    // MARK: - 2. Comprar Producto
    func purchase(_ product: Product) async throws {
        let result = try await product.purchase()
        
        switch result {
        case .success(let verification):
            // La compra fue exitosa, ahora verificamos la firma criptográfica
            let transaction = try checkVerified(verification)
            
            // Entregamos el contenido al usuario
            await updateCustomerProductStatus()
            
            // Le decimos a StoreKit que hemos terminado de procesar
            await transaction.finish()
            
        case .userCancelled, .pending:
            break
        default:
            break
        }
    }
    
    // MARK: - 3. Verificar Estado del Usuario (Restore)
    func updateCustomerProductStatus() async {
        // Iteramos sobre los derechos (entitlements) actuales del usuario
        for await result in Transaction.currentEntitlements {
            do {
                let transaction = try checkVerified(result)
                
                // Si encontramos nuestro producto ID, activamos la versión Pro
                if transaction.productID == "com.tuempresa.tuapp.premium_lifetime" {
                    hasUnlockedPro = true
                }
            } catch {
                print("Fallo en verificación")
            }
        }
    }
    
    // MARK: - 4. Escucha Activa de Transacciones
    /* Esto es vital. Si una compra se aprueba fuera de la app (ej. Control Parental, 
     o se renueva una suscripción), este listener lo capturará.
    */
    func listenForTransactions() -> Task<Void, Error> {
        return Task.detached {
            for await result in Transaction.updates {
                do {
                    let transaction = try self.checkVerified(result)
                    
                    // Actualizamos la UI en el hilo principal
                    await self.updateCustomerProductStatus()
                    
                    await transaction.finish()
                } catch {
                    print("Error en transacción verificada")
                }
            }
        }
    }
    
    // Función auxiliar para verificar la firma criptográfica de Apple
    func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {
        switch result {
        case .unverified:
            throw StoreError.failedVerification
        case .verified(let safe):
            return safe
        }
    }
}

import SwiftUI
import StoreKit

struct PaywallView: View {
    @EnvironmentObject var storeManager: StoreManager
    @Environment(\.dismiss) var dismiss
    
    var body: some View {
        ScrollView {
            VStack(spacing: 20) {
                // Header
                Image(systemName: "crown.fill")
                    .resizable()
                    .scaledToFit()
                    .frame(width: 80, height: 80)
                    .foregroundColor(.yellow)
                    .padding(.top, 40)
                
                Text("Desbloquea Premium")
                    .font(.largeTitle.bold())
                
                Text("Obtén acceso ilimitado a todas las funcionalidades, sincronización en la nube y soporte prioritario.")
                    .multilineTextAlignment(.center)
                    .padding(.horizontal)
                    .foregroundColor(.secondary)
                
                // Lista de Beneficios
                VStack(alignment: .leading, spacing: 15) {
                    FeatureRow(icon: "icloud", text: "Sincronización iCloud")
                    FeatureRow(icon: "chart.bar", text: "Estadísticas Avanzadas")
                    FeatureRow(icon: "lock.open", text: "Sin Anuncios")
                }
                .padding(.vertical)
                
                // Tarjetas de Productos
                if storeManager.products.isEmpty {
                    ProgressView("Cargando precios...")
                } else {
                    ForEach(storeManager.products) { product in
                        ProductButton(product: product) {
                            Task {
                                try? await storeManager.purchase(product)
                            }
                        }
                    }
                }
                
                // Botón Restaurar (Aunque StoreKit 2 lo hace automático, Apple recomienda ponerlo)
                Button("Restaurar Compras") {
                    Task {
                        await storeManager.updateCustomerProductStatus()
                    }
                }
                .font(.footnote)
                .foregroundColor(.secondary)
                .padding(.top)
            }
            .padding()
        }
        .onChange(of: storeManager.hasUnlockedPro) { newValue in
            if newValue {
                // Cerrar la paywall si la compra es exitosa
                dismiss()
            }
        }
    }
}

// Subvista para el botón de compra
struct ProductButton: View {
    let product: Product
    let action: () -> Void
    
    var body: some View {
        Button(action: action) {
            HStack {
                VStack(alignment: .leading) {
                    Text(product.displayName)
                        .font(.headline)
                    Text(product.description)
                        .font(.caption)
                        .foregroundColor(.secondary)
                }
                
                Spacer()
                
                Text(product.displayPrice)
                    .padding(8)
                    .background(Color.blue)
                    .foregroundColor(.white)
                    .cornerRadius(8)
            }
            .padding()
            .background(Color("CardBackground")) // Define este color en tus Assets
            .cornerRadius(12)
            .overlay(
                RoundedRectangle(cornerRadius: 12)
                    .stroke(Color.blue, lineWidth: 2)
            )
        }
        .buttonStyle(.plain)
    }
}

struct FeatureRow: View {
    let icon: String
    let text: String
    
    var body: some View {
        HStack {
            Image(systemName: icon)
                .foregroundColor(.blue)
                .frame(width: 30)
            Text(text)
        }
    }
}

import SwiftUI

@main
struct MiAppIncreible: App {
    // Inicializamos el StoreManager como StateObject para que viva toda la sesión
    @StateObject private var storeManager = StoreManager()
    
    var body: some Scene {
        WindowGroup {
            ContentView()
                .environmentObject(storeManager) // Inyectamos al entorno
        }
    }
}

struct ContentView: View {
    @EnvironmentObject var storeManager: StoreManager
    @State private var showPaywall = false
    
    var body: some View {
        NavigationStack {
            VStack {
                if storeManager.hasUnlockedPro {
                    Text("¡Bienvenido Usuario Premium!")
                        .font(.title)
                        .foregroundColor(.green)
                    // Contenido exclusivo aquí
                } else {
                    Text("Modo Gratuito")
                    Button("Hazte Premium") {
                        showPaywall = true
                    }
                    .buttonStyle(.borderedProminent)
                }
            }
            .sheet(isPresented: $showPaywall) {
                PaywallView()
            }
        }
    }
}

#if os(watchOS)
ScrollView {
    VStack {
        Text("Hazte Pro").font(.headline)
        // Botón simplificado
    }
}
#else
// Tu diseño complejo para iOS/macOS
#endif

import StoreKit

struct SimplePaywall: View {
    var body: some View {
        SubscriptionStoreView(groupID: "tu_grupo_de_suscripcion")
    }
}