Cómo agregar compras directas desde la aplicación a tu app de Flutter

1. Introducción

Para agregar compras directas desde la app a una app de Flutter, se deben configurar App Store de Apple y Google Play Store, verificar los tokens de compra en un backend de confianza y otorgar derechos, como monedas consumibles, actualizaciones únicas o beneficios de suscripción recurrente.

En este codelab, colaborarás con Google Antigravity para compilar Dash Clicker, un juego de clics para dispositivos móviles que usa la mascota Dash como moneda, y lo vincularás con un servicio de backend de Dart shelf y Cloud Firestore para validar y hacer un seguimiento de tres tipos de compras directas desde la app:

  1. Consumible (dash_consumable_2k): Es una compra repetible que otorga de inmediato 2,000 Dashes al jugador y se puede comprar varias veces.
  2. No consumible (dash_upgrade_3d): Una actualización permanente que transforma la mascota clásica de Dash en una versión moderna en 3D para siempre.
  3. Suscripción (dash_subscription_doubler): Es una suscripción con renovación automática que multiplica los clics generados de forma pasiva mientras la suscripción permanece activa.

Pantalla principal de Dash Clicker que muestra la mascota clásica de Dash y el contador de toques

Pantalla de compra de Dash Clicker en la que se muestran los productos integrados en la aplicación disponibles y las compras anteriores

Pantalla principal de Dash Clicker después de comprar la actualización de Dash 3D

Qué compilarás

  • Una app para dispositivos móviles de Flutter (app/) con diseño de material_ui y cupertino_ui que consulta productos de la tienda, inicia compras y reacciona a transmisiones de compras en tiempo real
  • Un servidor de backend de Dart shelf (dart-backend/) que verifica los recibos de compra con Google Play y la tienda de aplicaciones, sondea los eventos de facturación de la tienda y registra los estados de compra en Cloud Firestore.

Tu proceso de aprendizaje

En este codelab, se te guiará para que compiles y conectes el flujo de compra directa desde la app de pila completa paso a paso:

  1. Configura el entorno de desarrollo: Instala Flutter y Google Antigravity, pídele a Antigravity que cree la estructura del proyecto inicial de Dash Clicker (app/) y configura tu identificador de paquete de iOS y el applicationId de Android.
  2. Instala el complemento: Pídele a Antigravity que agregue in_app_purchase y in_app_purchase_platform_interface a app/.
  3. Configura la tienda de aplicaciones: Registra tu ID de aplicación, crea una cuenta de prueba de la zona de pruebas y configura los tres productos en App Store Connect.
  4. Configura Play Store: Crea tu app en Google Play Console, pídele a Antigravity que configure la firma del almacén de claves de lanzamiento en Gradle, sube un paquete de aplicación inicial, agrega verificadores de licencias y configura los productos.
  5. Configura Firebase: Habilita Acceso con Google y Cloud Firestore en Firebase console, ejecuta flutterfire configure y configura las huellas digitales SHA-1 de Android y los esquemas de URL de iOS.
  6. Escucha las actualizaciones de compras: Solicita a Antigravity que agregue un wrapper de IAPConnection que se pueda probar, suscríbete a purchaseStream y prueba la app con TestIAPConnection.
  7. Realiza compras: Indica a Antigravity que una ProductDetails en PurchasableProduct, consulte los productos de la tienda, active buyConsumable y buyNonConsumable, y complete las compras pendientes.
  8. Configura el backend: Pídele a Antigravity que cree la estructura del servidor de dart-backend/ con IapRepository y configure las credenciales de la cuenta de servicio.
  9. Verifica las compras: Indica a Antigravity que exija el acceso a Firebase en PurchasePage, que publique tokens de compra en /verifypurchase y que implemente GooglePlayPurchaseHandler y AppStorePurchaseHandler.
  10. Realiza un seguimiento de las compras: Solicita a Antigravity que sondee Google Cloud Pub/Sub y la API de App Store Server en el backend, y sincroniza los derechos con el cliente de Flutter usando IAPRepo.

Qué aprenderás

  • Cómo colaborar con Google Antigravity para compilar y personalizar de forma iterativa una app de compras directas desde la app de Flutter de pila completa y un backend de Dart.
  • Cómo configurar App Store Connect y Google Play Console con productos consumibles, no consumibles y de suscripción
  • Cómo consultar productos, iniciar compras y controlar flujos de compras con el complemento in_app_purchase
  • Cómo verificar los tokens de compra de Google Play y App Store en un backend de Dart y almacenarlos en Cloud Firestore
  • Cómo procesar eventos de facturación de la tienda y sincronizar los derechos de suscripción y actualización en todos los dispositivos

Requisitos previos

  • Conocimientos básicos sobre los widgets de Flutter, la sintaxis de Dart y la administración de estados de Provider
  • Una cuenta de desarrollador de Apple (para probar las compras de la tienda de aplicaciones en iOS), una cuenta de desarrollador de Google Play (para probar las compras de Play Store en Android) o ambas.
  • Una cuenta de Firebase y la CLI de Firebase

2. Cómo configurar el entorno de desarrollo

Editor

En este codelab, se usa Google Antigravity como tu entorno de desarrollo centrado en la IA. En cada paso, le darás instrucciones a Antigravity para que genere o evolucione tu cliente de Flutter (app/) y tu backend de Dart (dart-backend/), inspeccionarás el código generado y, de forma opcional, explorarás variaciones.

Instala Flutter

Podrás encontrar las instrucciones más actualizadas para instalar el SDK de Flutter en docs.flutter.dev.

Para este codelab, instala el siguiente software:

  1. El SDK de Flutter
  2. Google Antigravity con el complemento oficial de Dart y Flutter habilitado (disponible en el Marketplace de complementos en la sección Build with Google)
  3. Software de compilación para el destino móvil que elijas (Android Studio para Android o Xcode para iOS)

Indícale a Antigravity que cree el proyecto de partida

  1. Inicia Google Antigravity y abre un directorio de espacio de trabajo vacío en el que quieras compilar tu app de Flutter (app/) y el servidor de Dart (dart-backend/). Elige una ruta de acceso que no requiera privilegios elevados ni contenga espacios, como una carpeta en tu directorio principal o C:\src\.
  2. En el panel de chat del agente de Antigravity, envía la siguiente instrucción para crear la estructura de la app de inicio de Dash Clicker en app/:
Create a new empty Flutter project in `app/` named `dashclicker` targeting Android and iOS (`flutter create app --project-name dashclicker --empty --platforms android,ios`). Add the `cloud_firestore`, `cupertino_icons`, `firebase_auth`, `firebase_core`, `google_sign_in`, `http`, `intl`, `provider`, `logging`, `material_ui`, and `cupertino_ui` packages. Download `dash_old.png` and `dash.png` from `https://raw.githubusercontent.com/flutter/codelabs/main/in_app_purchases/step_00/app/assets/dash_old.png` and `https://raw.githubusercontent.com/flutter/codelabs/main/in_app_purchases/step_00/app/assets/dash.png` into `app/assets/` and register `assets/` under `flutter: assets:` in `app/pubspec.yaml`. Set `minSdk = 23` in `app/android/app/build.gradle.kts`, and add `GIDClientID` and `CFBundleURLTypes` placeholders in `app/ios/Runner/Info.plist`. Scaffold the Dash Clicker starter files using `package:material_ui/material_ui.dart` and `package:cupertino_ui/cupertino_ui.dart`:
- `lib/constants.dart` defining `cloudRegion = 'europe-west1'`, `storeKeyConsumable = 'dash_consumable_2k'`, `storeKeyUpgrade = 'dash_upgrade_3d'`, `storeKeySubscription = 'dash_subscription_doubler'`, and `serverIp = '192.168.178.46'`
- `lib/firebase_options.dart` with a placeholder `DefaultFirebaseOptions` for Android and iOS
- `lib/model/firebase_state.dart` (`enum FirebaseState { loading, available, notAvailable }`), `lib/model/store_state.dart` (`enum StoreState { loading, available, notAvailable }`), `lib/model/purchasable_product.dart` (`enum ProductStatus { purchasable, purchased, pending }` and `PurchasableProduct(this.title, this.description, this.price)`), and `lib/model/past_purchase.dart` (`PurchaseType`, `Store`, `Status`, and `PastPurchase.fromJson`)
- `lib/logic/dash_counter.dart` (`DashCounter extends ChangeNotifier` with `count`, `countString`, `increment()`, `addAutoIncrement()`, `applyPaidMultiplier()`, `removePaidMultiplier()`, `addBoughtDashes(int amount)`, and a 10Hz `Timer.periodic`)
- `lib/logic/dash_purchases.dart` (`DashPurchases extends ChangeNotifier` with `counter`, `storeState = StoreState.available`, mock `products`, `bool get beautifiedDash => false`, and a simulated `buy(PurchasableProduct product)` method)
- `lib/logic/dash_upgrades.dart` (`DashUpgrades extends ChangeNotifier` and `Upgrade` for `'Tim Sneath'`)
- `lib/logic/firebase_notifier.dart` (`FirebaseNotifier extends ChangeNotifier` initializing `Firebase.initializeApp`, `GoogleSignIn.instance`, `FirebaseAuth`, and `FirebaseFirestore`)
- `lib/repo/iap_repo.dart` (`IAPRepo extends ChangeNotifier` listening to Firebase auth changes and the `purchases` collection in Firestore)
- `lib/pages/home_page.dart` (`HomePage`, `DashClickerWidget`, `CounterStateWidget`, and `UpgradeList`), `lib/pages/login_page.dart` (`LoginPage`), and `lib/pages/purchase_page.dart` (`PurchasePage`, `_PurchasesLoading`, `_PurchasesNotAvailable`, `_PurchaseList`, `_PurchaseWidget`, and `PastPurchasesWidget`)
- `lib/main.dart` (`MyApp` and `MyHomePage` providing `FirebaseNotifier`, `DashCounter`, `DashUpgrades`, `IAPRepo`, and `DashPurchases` using `MultiProvider` with a `BottomNavigationBar` switching between `HomePage` and `PurchasePage`)
- `test/widget_test.dart` pumping `const MyApp()` and verifying `find.text('Tim Sneath')`.

Información sobre el código de partida generado

Antigravity crea el proyecto de Flutter app/ y genera la estructura de la arquitectura del juego Dash Clicker con Provider y ChangeNotifier:

  • app/lib/main.dart registra cinco ChangeNotifierProvider (FirebaseNotifier, DashCounter, DashUpgrades, IAPRepo y DashPurchases) dentro de MyHomePage y cambia entre HomePage y PurchasePage.
  • app/lib/constants.dart define los tres IDs de productos de la tienda que deben coincidir con los IDs que configuras en App Store Connect y Google Play Console:
const cloudRegion = 'europe-west1';
const storeKeyConsumable = 'dash_consumable_2k';
const storeKeyUpgrade = 'dash_upgrade_3d';
const storeKeySubscription = 'dash_subscription_doubler';

// TODO: Replace by your own server IP
const serverIp = '192.168.178.46';

Configura el identificador de paquete y el ID de aplicación de tu app

Para comunicarse con App Store y Play Store, tu app necesita un identificador de dominio inverso único (por ejemplo, dev.flutter.dashclicker). En iOS, se llama identificador de paquete; en Android, es el ID de aplicación. Usar el mismo identificador en ambas plataformas simplifica la configuración.

Primero, abre app/ios/Runner.xcworkspace en Xcode para configurar el identificador de paquete para iOS:

Abre Runner.xcworkspace en Xcode

En el navegador de proyectos de Xcode, selecciona Runner en la parte superior, abre la pestaña Signing & Capabilities, selecciona tu Team y, luego, ingresa tu identificador de paquete único:

Configuración del equipo y el identificador de paquete en Signing & Capabilities de Xcode

A continuación, actualiza el applicationId de Android en app/android/app/build.gradle.kts para que coincida con el identificador que elegiste (puedes editarlo directamente o pedirle a Antigravity que actualice el applicationId en app/android/app/build.gradle.kts con el ID que elegiste):

Configura applicationId en android/app/build.gradle.kts

3. Instala el complemento

En este paso, le pedirás a Antigravity que agregue el complemento in_app_purchase y su paquete de interfaz de plataforma (que se usa para simular conexiones de tienda en pruebas de widgets) a app/.

Solicita a Antigravity que instale in_app_purchase

En el panel de chat del agente de Antigravity, envía la siguiente instrucción:

In `app/`, add `in_app_purchase` to `dependencies` and `in_app_purchase_platform_interface` to `dev_dependencies` in `pubspec.yaml`.

Comprende el código generado

Antigravity ejecuta flutter pub add in_app_purchase dev:in_app_purchase_platform_interface dentro de app/, lo que actualiza app/pubspec.yaml:

dependencies:
  flutter:
    sdk: flutter
  cloud_firestore: ^7.1.0
  cupertino_icons: ^2.0.0
  cupertino_ui: ^1.1.6
  firebase_auth: ^7.0.1
  firebase_core: ^5.1.0
  google_sign_in: ^7.2.0
  http: ^1.6.0
  in_app_purchase: ^3.3.1
  intl: ^0.20.3
  logging: ^1.3.0
  material_ui: ^1.11.0
  provider: ^6.1.5+1

dev_dependencies:
  flutter_test:
    sdk: flutter
  flutter_lints: ^6.0.0
  in_app_purchase_platform_interface: ^1.4.1
  • in_app_purchase proporciona la API multiplataforma de InAppPurchase respaldada por StoreKit en iOS y Facturación Google Play en Android.
  • in_app_purchase_platform_interface expone InAppPurchasePlatformAddition, que te permite implementar un cliente InAppPurchase simulado en app/test/widget_test.dart.

4. Configura la tienda de aplicaciones

Para probar las compras directas desde la app en iOS, debes registrar tu app en App Store Connect y configurar los productos que se pueden comprar. No es necesario que publiques la app ni que la envíes para su revisión, pero sí necesitas una cuenta de desarrollador de Apple. Si no tienes una, inscríbete en el Apple Developer Program.

Para usar las compras directas desde la app, debes tener un acuerdo de Apps pagadas activo en App Store Connect. Ve a App Store Connect y selecciona Agreements, Tax, and Banking (o Business).

Panel principal de App Store Connect en el que se destacan los acuerdos, los impuestos y la información bancaria

Revisa los acuerdos para las apps gratuitas y pagadas. Consulta y acepta las condiciones de las aplicaciones pagadas, y, luego, ingresa la información fiscal y bancaria requerida.

Lista de acuerdos de App Store Connect que muestra las apps gratuitas activas y las apps pagadas nuevas

Cuando todo esté configurado, el estado de Aplicaciones pagadas cambiará a Activo. Sin un acuerdo de aplicación pagada activo, StoreKit no devolverá tus productos integrados en la aplicación durante las pruebas.

Lista de acuerdos de App Store Connect que muestra las apps gratuitas y pagadas activas

Registra un ID de app

Crea un ID de app nuevo en el portal para desarrolladores de Apple:

  1. Visita Apple Developer Identifiers y haz clic en el ícono + junto al encabezado Identifiers.Lista de identificadores del portal para desarrolladores de Apple con el botón para agregar destacado
  2. Selecciona App IDs y haz clic en Continue.Pantalla Register a new identifier con la opción App IDs seleccionada
  3. Selecciona Aplicación como el tipo y haz clic en Continuar.Pantalla para seleccionar un tipo con la opción App seleccionada
  4. Ingresa una descripción y establece el ID del paquete (explícito) en el identificador de paquete exacto que configuraste en Xcode. Asegúrate de que esté habilitada la función compra desde la app y, luego, registra el identificador.Formulario para registrar un ID de app que muestra la descripción y el ID del paquete explícito

Para obtener más detalles, consulta la ayuda de la cuenta de desarrollador de Apple.

Crea una app y un usuario de zona de pruebas nuevos

Crea una app nueva en App Store Connect con el identificador de paquete registrado:

Menú Apps de App Store Connect con la opción New App

Cuadro de diálogo Nueva app en App Store Connect que muestra los campos de plataforma, nombre, idioma, ID del paquete y SKU

Para obtener más orientación sobre cómo crear una app y administrar acuerdos, consulta la Ayuda de App Store Connect.

Para probar las compras directas desde la app sin cargos reales, crea una cuenta de Apple de zona de pruebas en App Store Connect, en Users and Access > Sandbox. Debes usar una dirección de correo electrónico que no esté asociada a una Cuenta de Apple.

Lista de verificadores de la zona de pruebas de App Store Connect

En tu iPhone o iPad de prueba, accede con tu cuenta de zona de pruebas en Configuración > Desarrollador > Cuenta de Apple de zona de pruebas.

Pantalla de configuración de iOS que muestra la sección Cuenta de Apple de la zona de pruebas

Pantalla de configuración de iOS que muestra una cuenta de Apple de zona de pruebas con la que se accedió

Configura tus compras directas desde la app

A continuación, configura los tres elementos que se pueden comprar en App Store Connect:

  • dash_consumable_2k: Es una compra consumible que se puede realizar de forma repetida y que otorga 2,000 Dashes por compra.
  • dash_upgrade_3d: Es una compra de actualización no consumible que solo se puede comprar una vez y que desbloquea la mascota de Dash en 3D.
  • dash_subscription_doubler: Es una suscripción con renovación automática que multiplica los clics pasivos mientras está activa.

Barra lateral de App Store Connect en la que se destacan las compras directas desde la app y las suscripciones

En las secciones Compras directas desde la app (y Suscripciones) de tu app, crea los tres productos con estos IDs de producto exactos:

  1. Consumible (dash_consumable_2k):
    • Crea un producto Consumible con el nombre de referencia dash consumable 2k y el ID del producto dash_consumable_2k.Crea un modal de compra directa desde la app configurado para dash_consumable_2k
    • Configura la disponibilidad para que el producto esté disponible en el país o la región del usuario de la zona de pruebas.Configuración de disponibilidad para la compra directa desde la app
    • Establece el precio en \$1.99 (o el equivalente en la moneda local).Se estableció la configuración de la programación de precios en USD 1.99
    • Agrega una localización con el nombre visible Spring is in the air y la descripción 2000 dashes fly out.Localización de la tienda de aplicaciones que muestra el nombre visible y la descripción
    • Sube una captura de pantalla de la opinión. El contenido de la imagen no importa para las pruebas de la zona de pruebas, pero subir una captura de pantalla cambia el estado del producto a Listo para enviar, lo que es necesario para que la app recupere el producto de StoreKit.Sección de información de la revisión con una imagen de vista previa del producto subido
  2. No consumible (dash_upgrade_3d):
    • Crea un producto no consumible con el nombre de referencia dash upgrade 3d y el ID de producto dash_upgrade_3d.
    • Establece el nombre visible en 3D Dash, la descripción en Brings your dash back to the future y el precio en \$0.99.
    • Configura la disponibilidad y sube una captura de pantalla de revisión tal como lo hiciste para dash_consumable_2k.Configuración del producto no consumible para dash_upgrade_3d
  3. Suscripción con renovación automática (dash_subscription_doubler):
    • En Suscripciones, crea un grupo de suscripciones llamado subscriptions (los usuarios solo pueden suscribirse a un producto del mismo grupo a la vez y pueden actualizar o cambiar a una versión inferior dentro del grupo).Diálogo Crear grupo de suscripciones
    • Agrega una localización de tienda de aplicaciones para el grupo de suscripciones.Cuadro de diálogo de localización de tienda de aplicaciones para el grupo de suscripciones
    • Dentro del grupo, crea una suscripción con el nombre de referencia dash subscription doubler y el ID del producto dash_subscription_doubler.Diálogo Crear suscripción para dash_subscription_doubler
    • Establece la duración de la suscripción en 1 semana, el nombre visible en Jet Engine, la descripción en Doubles your clicks y el precio en \$0.49. Configura la disponibilidad y sube una captura de pantalla de revisión para que su estado cambie a Listo para enviar.Duración, precio y configuración de localización de la suscripción

Tus productos deberían aparecer en App Store Connect con el estado Ready to Submit:

Lista de compras directas desde la app que muestra dash_consumable_2k y dash_upgrade_3d como listas para enviar

Lista de suscripciones que muestra dash_subscription_doubler como Listo para enviar

5. Configura Play Store

Para probar las compras directas desde la app en Android, necesitas una cuenta de desarrollador de Google Play. Si todavía no tienes una, regístrate para obtener una cuenta de desarrollador de Google Play.

Crear una app nueva

Crea una app nueva en Google Play Console:

  1. Abre Google Play Console.
  2. Selecciona Todas las apps > Crear app.
  3. Elige un idioma predeterminado y, luego, ingresa un nombre para la app (puedes cambiarlo más adelante).
  4. Selecciona Juego como el tipo de app y Gratis como el modelo de precios.
  5. Completa las declaraciones de las Políticas del Programa para Desarrolladores y las Leyes de exportación de EE.UU. y, luego, selecciona Crear app.

Después de crear la app, completa las tareas iniciales de Configura tu app en el panel:

Panel de Google Play Console en el que se muestra la lista de tareas para configurar la app

Firma la aplicación

Para probar la Facturación Google Play, debes subir al menos una versión firmada de appbundle a un segmento de pruebas en Google Play Console.

Crea un almacén de claves

Si aún no tienes un almacén de claves de carga, genera uno desde la terminal.

En macOS o Linux:

keytool -genkey -v -keystore ~/key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias key

En Windows:

keytool -genkey -v -keystore c:\Users\USER_NAME\key.jks -storetype JKS -keyalg RSA -keysize 2048 -validity 10000 -alias key

Crear app/android/key.properties

Crea app/android/key.properties que contenga una referencia a tu almacén de claves:

storePassword=<password from previous step>
keyPassword=<password from previous step>
keyAlias=key
storeFile=<location of the key store file, such as /Users/<user name>/key.jks>

Pídele a Antigravity que configure la firma de la versión en Gradle

Envía la siguiente instrucción en Antigravity para conectar la firma de la versión en app/android/app/build.gradle.kts:

Update `app/android/app/build.gradle.kts` to load `key.properties` into a `Properties` object if the file exists, configure a `release` signing config inside `signingConfigs` using `keyAlias`, `keyPassword`, `storeFile`, and `storePassword`, and assign `signingConfigs.getByName("release")` to the `release` build type when `key.properties` is present.

Antigravity actualiza app/android/app/build.gradle.kts para cargar key.properties y firmar compilaciones de lanzamiento:

val keystoreProperties = Properties()
val keystorePropertiesFile = rootProject.file("key.properties")
if (keystorePropertiesFile.exists()) {
    keystoreProperties.load(FileInputStream(keystorePropertiesFile))
}

android {
    // ...
    signingConfigs {
        create("release") {
            keyAlias = keystoreProperties["keyAlias"] as String?
            keyPassword = keystoreProperties["keyPassword"] as String?
            storeFile = keystoreProperties["storeFile"]?.let { file(it) }
            storePassword = keystoreProperties["storePassword"] as String?
        }
    }

    buildTypes {
        release {
            signingConfig = signingConfigs.getByName("release")
        }
    }
}

Sube tu primera compilación

Compila un paquete de aplicación de lanzamiento firmado desde app/:

cd app
flutter build appbundle

El paquete de lanzamiento se escribe en app/build/app/outputs/bundle/release/app-release.aab.

En Google Play Console, navega a Prueba y lanza > Pruebas > Pruebas cerradas, crea una versión de prueba cerrada, sube app-release.aab y haz clic en Guardar > Revisar versión > Iniciar lanzamiento para pruebas cerradas.

Configura usuarios de prueba

Para probar las compras directas desde la app en Android, agrega las Cuentas de Google de tus verificadores en dos lugares de Google Play Console:

  1. Verificadores del segmento de pruebas: Ve a Prueba y lanza > Pruebas > Pruebas internas (o Pruebas cerradas), abre la pestaña Verificadores, haz clic en Crear lista de direcciones de correo electrónico, agrega las direcciones de correo electrónico de los verificadores, selecciona la lista y haz clic en Guardar cambios.Pestaña Verificadores de la sección Pruebas internas de Google Play Console
  2. Verificadores con licencias: Regresa a la vista Todas las apps, selecciona Configuración > Prueba de licencia, agrega las mismas direcciones de correo electrónico de los verificadores, establece la Respuesta de licencia en RESPOND_NORMALLY y haz clic en Guardar cambios.Configuración de las pruebas de licencias de Google Play Console

Configura tus compras directas desde la app

Configura los mismos tres IDs de productos en Google Play Console:

  • dash_consumable_2k: Compra consumible que otorga 2,000 Dashes.
  • dash_upgrade_3d: Actualización única no consumible de Dash en 3D.
  • dash_subscription_doubler: Suscripción con renovación automática de multiplicador de clics.

Primero, crea los productos únicos (dash_consumable_2k y dash_upgrade_3d):

  1. Selecciona tu app en Google Play Console y navega a Monetiza con Play > Productos > Productos integrados en la aplicación.
  2. Haz clic en Crear producto.Página de productos integrados en la aplicación de Google Play Console con el botón Crear producto
  3. Ingresa el ID del producto (dash_consumable_2k), el nombre, la descripción y el precio exactos y, luego, haz clic en Guardar y Activar.
  4. Repite el proceso para dash_upgrade_3d.

A continuación, crea la suscripción (dash_subscription_doubler):

  1. Navega a Monetiza con Play > Productos > Suscripciones y haz clic en Crear suscripción.Página Suscripciones de Google Play Console con el botón Crear suscripción
  2. Ingresa el ID del producto (dash_subscription_doubler), agrega un plan básico con un período de facturación semanal y un precio, y, luego, haz clic en Guardar y Activar.

6. Configura Firebase

Usar un servicio de backend con Cloud Firestore para verificar y hacer un seguimiento de las compras le brinda a tu app varias ventajas de seguridad:

  • Verificas las transacciones directamente con los servidores de Google Play y Apple.
  • Puedes reaccionar a los eventos de facturación del servidor (como renovaciones o cancelaciones).
  • Almacenas una fuente única de información en Cloud Firestore asociada con cada usuario autenticado.
  • Los usuarios no pueden desbloquear beneficios premium alterando el reloj de su dispositivo.

Crea un proyecto de Firebase

  1. Abre Firebase console y crea un proyecto de Firebase nuevo (por ejemplo, Dash Clicker).
  2. Navega a Compilar > Autenticación, haz clic en Comenzar, abre la pestaña Método de acceso y habilita el proveedor de acceso de Google.Pestaña Método de acceso de Firebase Authentication que muestra Google habilitado
  3. Navega a Compilación > Base de datos de Firestore y crea una base de datos.Banner de creación de Cloud Firestore en Firebase console
  4. Abre la pestaña Reglas en Cloud Firestore y publica las siguientes reglas de seguridad para que los usuarios autenticados solo puedan leer sus propios documentos de compra:
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /purchases/{purchaseId} {
      allow read: if request.auth != null && request.auth.uid == resource.data.userId
    }
  }
}

Configura Firebase para Flutter

Sigue la guía de configuración de FlutterFire para instalar la CLI de FlutterFire y, luego, ejecuta flutterfire configure dentro de app/:

cd app
flutterfire configure
  1. Selecciona el proyecto de Firebase que creaste.
  2. Habilita android y ios.
  3. Confirma con yes cuando se te solicite anular lib/firebase_options.dart.

Configura Firebase para Android: Certificado SHA-1 de depuración

Para usar Acceso con Google en Android, debes registrar la huella digital SHA-1 de tu almacén de claves de depuración en Firebase console:

  1. En Firebase console, abre Descripción general del proyecto > Configuración del proyecto > General, desplázate hacia abajo hasta Tus apps y selecciona tu app para Android:Configuración del proyecto de Firebase que muestra la configuración de la app para Android y el botón Agregar huella digital
  2. Genera un informe de firma desde app/android/:
    cd app/android
    ./gradlew :app:signingReport
    
  3. Busca la huella digital SHA1 en Variant: debug y Config: debug, agrégala a tu app para Android en Firebase console y vuelve a ejecutar flutterfire configure en app/ para que google-services.json y lib/firebase_options.dart incluyan la configuración actualizada del cliente de OAuth.

Configura Firebase para iOS: Configura esquemas de URL

Para admitir el Acceso con Google en iOS, app/ios/Runner/Info.plist debe incluir el REVERSED_CLIENT_ID de app/ios/Runner/GoogleService-Info.plist dentro de CFBundleURLTypes (consulta los documentos de integración de iOS de google_sign_in).

Puedes pedirle a Antigravity que copie el REVERSED_CLIENT_ID y el CLIENT_ID de app/ios/Runner/GoogleService-Info.plist en app/ios/Runner/Info.plist:

Read `CLIENT_ID` and `REVERSED_CLIENT_ID` from `app/ios/Runner/GoogleService-Info.plist` and update `GIDClientID` and `CFBundleURLTypes` (`CFBundleURLSchemes`) in `app/ios/Runner/Info.plist` with those values.

En app/ios/Runner/Info.plist, la entrada CFBundleURLTypes tiene el siguiente aspecto:

<key>CFBundleURLTypes</key>
<array>
	<dict>
		<key>CFBundleTypeRole</key>
		<string>Editor</string>
		<key>CFBundleURLSchemes</key>
		<array>
			<string>com.googleusercontent.apps.YOUR_REVERSED_CLIENT_ID</string>
		</array>
	</dict>
</array>

7. Cómo escuchar las actualizaciones de compras

En este paso, prepararás la app de Flutter para que escuche las actualizaciones de compras de la tienda en cuanto se inicie la app y mantendrás el árbol de widgets comprobable con la introducción de un wrapper IAPConnection anulable.

Solicita a Antigravity que escuche las actualizaciones de compras

Envía la siguiente instrucción en Antigravity:

Update `app/lib/main.dart` to define an `IAPConnection` class with a static `InAppPurchase? _instance` and a static getter and setter for `instance` (defaulting to `InAppPurchase.instance`), and set `lazy: false` on `ChangeNotifierProvider<DashPurchases>`. Update `DashPurchases` in `app/lib/logic/dash_purchases.dart` to set `storeState = StoreState.notAvailable`, hold `final iapConnection = IAPConnection.instance` and `late StreamSubscription<List<PurchaseDetails>> _subscription`, subscribe to `iapConnection.purchaseStream.listen(_onPurchaseUpdate, onDone: _updateStreamOnDone, onError: _updateStreamOnError)` in the constructor, cancel `_subscription` in `dispose()`, and add `_onPurchaseUpdate`, `_updateStreamOnDone`, and `_updateStreamOnError` methods. Finally, update `app/test/widget_test.dart` to define `TestIAPConnection implements InAppPurchase` and set `IAPConnection.instance = TestIAPConnection()` before pumping `MyApp`.

Comprende el código generado

Inicialización de proveedores diligentes y IAPConnection en app/lib/main.dart

De forma predeterminada, Provider crea su valor de forma diferida cuando un widget lo lee por primera vez. Debido a que las transacciones pendientes de la tienda pueden llegar a purchaseStream inmediatamente después del inicio, ChangeNotifierProvider establece lazy: false. Además, IAPConnection proporciona una unión estática para que las pruebas de widgets puedan insertar una implementación de InAppPurchase falsa:

class IAPConnection {
  static InAppPurchase? _instance;
  static set instance(InAppPurchase value) {
    _instance = value;
  }

  static InAppPurchase get instance {
    _instance ??= InAppPurchase.instance;
    return _instance!;
  }
}
ChangeNotifierProvider<DashPurchases>(
  create: (context) => DashPurchases(context.read<DashCounter>()),
  lazy: false,
),

Te suscribirás a purchaseStream en app/lib/logic/dash_purchases.dart

En DashPurchases, el constructor se suscribe a iapConnection.purchaseStream y dispose() cancela _subscription:

  final iapConnection = IAPConnection.instance;

  DashPurchases(this.counter) {
    final purchaseUpdated = iapConnection.purchaseStream;
    _subscription = purchaseUpdated.listen(
      _onPurchaseUpdate,
      onDone: _updateStreamOnDone,
      onError: _updateStreamOnError,
    );
  }

  @override
  void dispose() {
    _subscription.cancel();
    super.dispose();
  }

Ejecuta y prueba la app

Ejecuta el paquete de pruebas de widgets en app/ para verificar que TestIAPConnection simule la conexión de la tienda de forma limpia:

cd app
flutter test

8. Hacer compras

En este paso, reemplazarás los productos simulados codificados con productos de la tienda en vivo recuperados con queryProductDetails, iniciarás compras cuando el usuario presione un producto y completarás transacciones cuando lleguen actualizaciones a purchaseStream.

Indícale a Antigravity que cargue y realice compras

Envía la siguiente instrucción en Antigravity:

Update `PurchasableProduct` in `app/lib/model/purchasable_product.dart` to wrap a `ProductDetails productDetails` from `package:in_app_purchase/in_app_purchase.dart`, exposing `id`, `title`, `description`, and `price` getters from `productDetails` and initializing `status = ProductStatus.purchasable`. Then update `DashPurchases` in `app/lib/logic/dash_purchases.dart` to initialize `storeState = StoreState.loading`, `products = []`, and `bool _beautifiedDashUpgrade = false` (backing `beautifiedDash`), call `loadPurchases()` in the constructor to check `iapConnection.isAvailable()` and query `{storeKeyConsumable, storeKeySubscription, storeKeyUpgrade}` with `iapConnection.queryProductDetails(ids)`, implement `buy(PurchasableProduct product)` using `PurchaseParam` to call `iapConnection.buyConsumable` for `storeKeyConsumable` and `iapConnection.buyNonConsumable` for `storeKeySubscription` and `storeKeyUpgrade`, and implement `_onPurchaseUpdate` and `_handlePurchase(PurchaseDetails purchaseDetails)` to apply `PurchaseStatus.purchased` rewards (`counter.applyPaidMultiplier()`, `counter.addBoughtDashes(2000)`, `_beautifiedDashUpgrade = true`) and call `iapConnection.completePurchase(purchaseDetails)` when `purchaseDetails.pendingCompletePurchase` is true.

Comprende el código generado

Cómo unir ProductDetails en app/lib/model/purchasable_product.dart

PurchasableProduct une el ProductDetails que muestra el almacén mientras se hace un seguimiento del ProductStatus de la IU local (purchasable, purchased o pending):

class PurchasableProduct {
  String get id => productDetails.id;
  String get title => productDetails.title;
  String get description => productDetails.description;
  String get price => productDetails.price;
  ProductStatus status;
  ProductDetails productDetails;

  PurchasableProduct(this.productDetails) : status = ProductStatus.purchasable;
}

Consultando productos en app/lib/logic/dash_purchases.dart

loadPurchases() primero verifica que se pueda acceder a la tienda subyacente con iapConnection.isAvailable() y, luego, consulta los tres IDs de producto definidos en app/lib/constants.dart:

  Future<void> loadPurchases() async {
    final available = await iapConnection.isAvailable();
    if (!available) {
      storeState = StoreState.notAvailable;
      notifyListeners();
      return;
    }
    const ids = <String>{
      storeKeyConsumable,
      storeKeySubscription,
      storeKeyUpgrade,
    };
    final response = await iapConnection.queryProductDetails(ids);
    products = response.productDetails
        .map((e) => PurchasableProduct(e))
        .toList();
    storeState = StoreState.available;
    notifyListeners();
  }

Iniciar y completar compras

Cuando un usuario presiona un producto en PurchasePage, buy() construye un PurchaseParam y envía consumibles a buyConsumable y actualizaciones o suscripciones únicas a buyNonConsumable:

  Future<void> buy(PurchasableProduct product) async {
    final purchaseParam = PurchaseParam(productDetails: product.productDetails);
    switch (product.id) {
      case storeKeyConsumable:
        await iapConnection.buyConsumable(purchaseParam: purchaseParam);
      case storeKeySubscription:
      case storeKeyUpgrade:
        await iapConnection.buyNonConsumable(purchaseParam: purchaseParam);
      default:
        throw ArgumentError.value(
          product.productDetails,
          '${product.id} is not a known product',
        );
    }
  }

Cuando Play Store emite objetos PurchaseDetails actualizados en purchaseStream, _handlePurchase otorga la recompensa correspondiente y confirma la finalización llamando a completePurchase:

  Future<void> _handlePurchase(PurchaseDetails purchaseDetails) async {
    if (purchaseDetails.status == PurchaseStatus.purchased) {
      switch (purchaseDetails.productID) {
        case storeKeySubscription:
          counter.applyPaidMultiplier();
        case storeKeyConsumable:
          counter.addBoughtDashes(2000);
        case storeKeyUpgrade:
          _beautifiedDashUpgrade = true;
      }
    }

    if (purchaseDetails.pendingCompletePurchase) {
      await iapConnection.completePurchase(purchaseDetails);
    }
  }

Ejecuta y prueba la app

Ejecuta flutter test en app/ y, luego, inicia la app en el dispositivo de prueba configurado. Cuando los productos de tu tienda estén activos, la pestaña Purchase los mostrará listos para la compra:

Pestaña Purchase de Dash Clicker en la que se muestran los tres productos de la tienda cargados desde la tienda

9. Configura el backend

Antes de verificar y hacer un seguimiento de las compras en un servidor, crearás la estructura del servicio de backend de Dart en dart-backend/ junto con app/ y configurarás las credenciales para Firebase, Google Play y App Store.

Instruye a Antigravity para que cree la estructura del backend de Dart

En el panel de chat del agente de Antigravity, envía la siguiente instrucción para crear el proyecto de dart-backend/:

Create a Dart shelf server project in `dart-backend/` with package name `firebase_backend_dart` (`dart create -t server-shelf`). Add `googleapis: ^16.0.0`, `googleapis_auth`, `http`, and `app_store_server_sdk` to `dependencies`, and `test` to `dev_dependencies` (configuring `deprecated_member_use: ignore` in `dart-backend/analysis_options.yaml`). Create:
- `dart-backend/lib/constants.dart` defining `androidPackageId`, `appStoreIssuerId`, `appStoreKeyId`, `appStoreSharedSecret`, `bundleId`, `googleCloudProjectId`, and `googlePlayPubsubBillingTopic = 'play_billing'`
- `dart-backend/lib/helpers.dart` with `serveHandler(Handler handler)`, `listenPort()`, and `terminateRequestFuture()` listening to `SIGINT` and `SIGTERM`
- `dart-backend/lib/products.dart` defining `ProductData(this.productId, this.type)`, `enum ProductType { subscription, nonSubscription }`, and `productDataMap` for `'dash_consumable_2k'`, `'dash_upgrade_3d'`, and `'dash_subscription_doubler'`
- `dart-backend/lib/iap_repository.dart` defining `enum IAPSource { googleplay, appstore }`, `abstract class Purchase`, `NonSubscriptionPurchase`, `SubscriptionPurchase`, and `IapRepository(this.api, this.projectId)` using `package:googleapis/firestore/v1.dart` (`createOrUpdatePurchase`, `updatePurchase`, and `getPurchases`)
- `dart-backend/bin/server.dart` starting an empty `Router()` with `await serveHandler(router.call)`.

Comprende el código generado

  • dart-backend/bin/server.dart inicializa un Router shelf_router y entrega solicitudes HTTP en el puerto 8080 con serveHandler en dart-backend/lib/helpers.dart.
  • dart-backend/lib/products.dart asigna cada ID de producto (dash_consumable_2k, dash_upgrade_3d y dash_subscription_doubler) a su ProductType (nonSubscription o subscription).
  • dart-backend/lib/iap_repository.dart encapsula la lectura y escritura de documentos NonSubscriptionPurchase y SubscriptionPurchase en la colección purchases de Cloud Firestore con FirestoreApi.

Para probar que el servidor se inicie de forma local, ejecuta lo siguiente:

cd dart-backend
dart run ./bin/server.dart

Configura el acceso a Firebase

Para permitir que dart-backend/ escriba compras verificadas en Cloud Firestore, genera una clave de cuenta de servicio:

  1. En Firebase console, abre Configuración del proyecto > Cuentas de servicio y haz clic en Generar nueva clave privada.Pestaña Cuentas de servicio de la configuración del proyecto de Firebase en la que se muestra la opción Generar nueva clave privada
  2. Guarda el archivo JSON descargado como dart-backend/assets/service-account-firebase.json.

Configura el acceso a Google Play

Para permitir que dart-backend/ verifique las compras de Android con la API de Google Play Android Developer, haz lo siguiente:

  1. Abre la página de la API de Google Play Android Developer en la consola de Google Cloud y habilita la API.Página de la consola de Google Cloud para la API de Google Play Android Developer
  2. Ve a la página Cuentas de servicio de Google Cloud y haz clic en + Crear cuenta de servicio.Página Cuentas de servicio de la consola de Google Cloud en la que se muestra la opción Crear cuenta de servicio
  3. Ingresa un nombre para la cuenta de servicio y haz clic en Crear y continuar.Paso de detalles de la cuenta de servicio
  4. Otorga el rol Suscriptor de Pub/Sub y haz clic en Listo.Paso Otorgar a esta cuenta de servicio acceso al proyecto en el que se muestra el rol de suscriptor de Pub/Sub
  5. Abre el menú de acciones de la cuenta de servicio recién creada y selecciona Administrar claves.Menú de acciones de la cuenta de servicio en el que se destaca Administrar claves
  6. Selecciona Agregar clave > Crear clave nueva, elige JSON y descarga la clave:Menú Agregar clave que muestra Crear clave nuevaCuadro de diálogo Crear clave privada con JSON seleccionado
  7. Guarda el archivo descargado como dart-backend/assets/service-account-google-play.json.
  8. Abre Usuarios y permisos en Google Play Console, haz clic en Invitar a usuarios nuevos y, luego, ingresa la dirección de correo electrónico de la cuenta de servicio:Página Usuarios y permisos de Google Play ConsoleTabla de cuentas de servicio de Google Cloud en la que se muestra la dirección de correo electrónico de la cuenta de servicio
  9. Otorga los permisos Ver los datos financieros y Administrar pedidos y suscripciones para tu app y, luego, haz clic en Invitar usuario.Pestaña Permisos de la app en la que se muestran marcadas las opciones Ver los datos financieros y Administrar pedidos y suscripciones

Configura el acceso a la tienda de aplicaciones de Apple

Para verificar los recibos de la App Store en el backend, genera un secreto compartido específico de la app:

  1. Abre App Store Connect, selecciona Apps y elige tu app.
  2. En la barra lateral, navega a General > Información de la app.
  3. En Secreto compartido específico de la app, haz clic en Administrar, genera un nuevo secreto compartido y cópialo:Sección Secreto compartido específico de la app de App Store ConnectModal de secreto compartido específico de la app que muestra el secreto generado

Actualizar dart-backend/lib/constants.dart

Asegúrate de que las siguientes constantes estén configuradas en dart-backend/lib/constants.dart:

  • androidPackageId: Es el applicationId de Android (como com.example.dashclicker).
  • appStoreSharedSecret: Es el secreto compartido de App Store Connect.
  • bundleId: Es el identificador de paquete de iOS (como com.example.dashclicker).

10. Verifica las compras

Cuando un usuario completa una compra en iOS o Android, la tienda de aplicaciones emite un token de verificación (PurchaseDetails.verificationData.serverVerificationData). En lugar de confiar directamente en el dispositivo cliente, la app de Flutter envía este token a dart-backend/, que lo verifica con Google Play o App Store y registra la compra en Cloud Firestore.

Jerarquía de clases de PurchaseHandler implementada por GooglePlayPurchaseHandler y AppStorePurchaseHandler

Solicita a Antigravity que verifique las compras en el cliente y el backend

Envía la siguiente instrucción en Antigravity para conectar la app de Flutter y el flujo de verificación del backend de Dart:

1. In `app/`:
- Update `PurchasePage` in `app/lib/pages/purchase_page.dart` to watch `FirebaseNotifier` and return `_PurchasesLoading()` when `state == FirebaseState.loading`, `_PurchasesNotAvailable()` when `state == FirebaseState.notAvailable`, and `const LoginPage()` when `!firebaseNotifier.loggedIn`.
- Add `User? get user => FirebaseAuth.instance.currentUser;` to `FirebaseNotifier` in `app/lib/logic/firebase_notifier.dart`.
- Update `DashPurchases` in `app/lib/logic/dash_purchases.dart` (and its provider in `app/lib/main.dart`) to accept `this.firebaseNotifier`, implement `_verifyPurchase(PurchaseDetails purchaseDetails)` that sends an HTTP `POST` request to `Uri.http('$serverIp:8080', '/verifypurchase')` with JSON body `{'source': purchaseDetails.verificationData.source, 'productId': purchaseDetails.productID, 'verificationData': purchaseDetails.verificationData.serverVerificationData, 'userId': firebaseNotifier.user?.uid}`, and update `_handlePurchase` so purchase rewards are only applied when `await _verifyPurchase(purchaseDetails)` returns `true`.

2. In `dart-backend/`:
- Create `dart-backend/lib/purchase_handler.dart` with `abstract class PurchaseHandler` defining `handleNonSubscription`, `handleSubscription`, and `verifyPurchase` switching on `productData.type`.
- Create `dart-backend/lib/google_play_purchase_handler.dart` with `GooglePlayPurchaseHandler extends PurchaseHandler` that verifies one-time purchases using `androidPublisher.purchases.products.get` and subscriptions using `androidPublisher.purchases.subscriptions.get`, parses order IDs with `extractOrderId(String orderId)` (stripping `..` renewal suffixes), maps statuses with `_nonSubscriptionStatusFrom` and `_subscriptionStatusFrom`, and saves purchases to `iapRepository`.
- Create `dart-backend/lib/app_store_purchase_handler.dart` with `AppStorePurchaseHandler extends PurchaseHandler` that validates receipts with `ITunesApi(ITunesHttpClient(ITunesEnvironment.sandbox(), loggingEnabled: true)).verifyReceipt` and saves `NonSubscriptionPurchase` and `SubscriptionPurchase` records to `iapRepository`.
- Update `dart-backend/bin/server.dart` to initialize `AndroidPublisherApi` and `FirestoreApi` from the service account JSON files in `_createPurchaseHandlers()`, register a `POST /verifypurchase` route, and extract request fields in `getPurchaseData(dynamic payload)` using Dart 3 map pattern matching.

Comprende el código generado

Restringir las compras detrás de la autenticación y llamar a /verifypurchase

En app/lib/pages/purchase_page.dart, PurchasePage verifica FirebaseNotifier y muestra LoginPage hasta que el usuario accede:

    var firebaseNotifier = context.watch<FirebaseNotifier>();
    if (firebaseNotifier.state == FirebaseState.loading) {
      return _PurchasesLoading();
    } else if (firebaseNotifier.state == FirebaseState.notAvailable) {
      return _PurchasesNotAvailable();
    }

    if (!firebaseNotifier.loggedIn) {
      return const LoginPage();
    }

En app/lib/logic/dash_purchases.dart, _verifyPurchase publica la fuente de la tienda (google_play o app_store), productID, serverVerificationData y el userId con el que se accedió al backend de Dart antes de que _handlePurchase otorgue la recompensa en la aplicación:

  Future<bool> _verifyPurchase(PurchaseDetails purchaseDetails) async {
    final url = Uri.http('$serverIp:8080', '/verifypurchase');
    const headers = {
      'Content-type': 'application/json',
      'Accept': 'application/json',
    };
    final response = await http.post(
      url,
      body: jsonEncode({
        'source': purchaseDetails.verificationData.source,
        'productId': purchaseDetails.productID,
        'verificationData':
            purchaseDetails.verificationData.serverVerificationData,
        'userId': firebaseNotifier.user?.uid,
      }),
      headers: headers,
    );
    if (response.statusCode == 200) {
      return true;
    } else {
      return false;
    }
  }

Enrutamiento y coincidencia de patrones de Dart 3 en dart-backend/bin/server.dart

En el servidor, POST /verifypurchase decodifica el cuerpo de la solicitud JSON con getPurchaseData usando un patrón de mapas de Dart 3 y un tipo de datos que se devuelve de registro, y, luego, delega la verificación al controlador de la tienda correspondiente:

  router.post('/verifypurchase', (Request request) async {
    final dynamic payload = json.decode(await request.readAsString());
    final (:userId, :source, :productData, :token) = getPurchaseData(payload);

    final result = await purchaseHandlers[source]!.verifyPurchase(
      userId: userId,
      productData: productData,
      token: token,
    );

    if (result) {
      return Response.ok('all good!');
    } else {
      return Response.internalServerError();
    }
  });
({String userId, String source, ProductData productData, String token})
getPurchaseData(dynamic payload) {
  if (payload case {
    'userId': String userId,
    'source': String source,
    'productId': String productId,
    'verificationData': String token,
  }) {
    return (
      userId: userId,
      source: source,
      productData: productDataMap[productId]!,
      token: token,
    );
  } else {
    throw const FormatException('Unexpected JSON');
  }
}

Verifica los recibos de Google Play y App Store

  • En dart-backend/lib/google_play_purchase_handler.dart, GooglePlayPurchaseHandler consulta androidPublisher.purchases.products.get para productos únicos y androidPublisher.purchases.subscriptions.get para suscripciones, quita los sufijos de renovación ..# de los IDs de pedidos de suscripción con extractOrderId y escribe el NonSubscriptionPurchase o SubscriptionPurchase resultante en Cloud Firestore con iapRepository.
  • En dart-backend/lib/app_store_purchase_handler.dart, AppStorePurchaseHandler llama a _iTunesAPI.verifyReceipt con el paquete app_store_server_sdk y conserva cada recibo verificado en response.latestReceiptInfo en Cloud Firestore.

Ejecuta y prueba el backend

Inicia el servidor de backend desde dart-backend/:

cd dart-backend
dart run bin/server.dart

11. Haz un seguimiento de las compras

Las suscripciones se pueden renovar, vencer o cancelar fuera de tu app. En este paso, configurarás el backend para que sondee las actualizaciones de facturación de la tienda de aplicaciones desde Google Cloud Pub/Sub y la API de App Store Server, y actualizarás el cliente de Flutter para que sincronice de forma reactiva los derechos activos del usuario desde Cloud Firestore con IAPRepo.

Configura las claves de API de Cloud Pub/Sub y de la API de App Store Server

Configuración de Cloud Pub/Sub de Google Play

  1. Establece googleCloudProjectId en dart-backend/lib/constants.dart como el ID de tu proyecto de Google Cloud y Firebase.
  2. Abre la página Temas de Cloud Pub/Sub en la consola de Google Cloud, asegúrate de que tu proyecto esté seleccionado y haz clic en + Crear tema.Página Temas de Google Cloud Pub/Sub en la que se muestra el botón Crear tema
  3. Establece el ID del tema como play_billing (que coincida con googlePlayPubsubBillingTopic en dart-backend/lib/constants.dart, lo que crea automáticamente una suscripción predeterminada play_billing-sub) y haz clic en Crear.Cuadro de diálogo Crear un tema con el ID de tema play_billing
  4. Abre el menú de tres puntos en tu tema play_billing y selecciona Ver permisos.Menú del tema de Pub/Sub en el que se destacan los permisos de lectura
  5. Haz clic en Agregar principal, ingresa google-play-developer-notifications@system.gserviceaccount.com, asigna el rol de Publicador de Pub/Sub y haz clic en Guardar.Panel Agregar principales que otorga el rol de publicador de Pub/Sub a google-play-developer-notifications
  6. Copia el nombre completo del tema, abre tu app en Google Play Console, ve a Monetiza con Play > Configuración de la monetización, pega el nombre del tema y haz clic en Guardar cambios.Configuración de la monetización de Google Play Console que muestra el nombre del tema de las notificaciones para desarrolladores en tiempo real

Configuración de la clave de la API de App Store Server

  1. Accede a App Store Connect y selecciona Users and Access.
  2. Navega a Integraciones > Claves > Compra directa desde la app y haz clic en el botón + para generar una clave nueva (por ejemplo, Codelab key).
  3. Descarga el archivo de claves .p8 y guárdalo como dart-backend/assets/SubscriptionKey.p8.
  4. Copia el ID de clave y el ID de emisor en appStoreKeyId y appStoreIssuerId en dart-backend/lib/constants.dart.

Lista de claves de compras directas desde la app de App Store Connect que muestra el ID de emisor y el ID de clave

Indica a Antigravity que sondee los eventos de la tienda y sincronice el estado del cliente

Envía la siguiente instrucción en Antigravity:

1. In `dart-backend/`:
- Update `GooglePlayPurchaseHandler` in `dart-backend/lib/google_play_purchase_handler.dart` to accept `pubsub.PubsubApi pubsubApi` from `package:googleapis/pubsub/v1.dart`, start a 10-second `Timer.periodic` calling `_pullMessageFromPubSub()`, decode base64 Pub/Sub messages in `_processMessage(String data64, String? ackId)` (handling `testNotification`, `subscriptionNotification`, and `oneTimeProductNotification`), and acknowledge processed messages in `_ackMessage(String id)`.
- Update `AppStorePurchaseHandler` in `dart-backend/lib/app_store_purchase_handler.dart` to accept `AppStoreServerAPI appStoreServerAPI`, start a 10-second `Timer.periodic` calling `_pullStatus()`, query `appStoreServerAPI.getAllSubscriptionStatuses(purchase.orderId)` for active App Store subscriptions in `iapRepository`, and update their expiration date and `SubscriptionStatus` in Firestore.
- Update `dart-backend/bin/server.dart` to add `pubsub.PubsubApi.cloudPlatformScope` to the Google Play client scopes, construct `PubsubApi` and `AppStoreServerAPI` (reading `assets/SubscriptionKey.p8` and caching JWT tokens in `assets/appstore.token`), and pass them to `GooglePlayPurchaseHandler` and `AppStorePurchaseHandler`.
- Create unit tests in `dart-backend/test/firebase_backend_dart_test.dart` verifying `extractOrderId` (with and without a `..0` suffix) and `getPurchaseData` (valid and invalid payloads).

2. In `app/`:
- Update `DashPurchases` in `app/lib/logic/dash_purchases.dart` (and its provider in `app/lib/main.dart`) to accept `this.iapRepo` (`IAPRepo`), register `iapRepo.addListener(purchasesUpdate)` in the constructor and `iapRepo.removeListener(purchasesUpdate)` in `dispose()`, and implement `purchasesUpdate()` and `_updateStatus(PurchasableProduct product, ProductStatus status)` (setting `product.status = status` when `product.status != status`) so `iapRepo.hasActiveSubscription` applies or removes the paid counter multiplier and `iapRepo.hasUpgrade` updates `_beautifiedDashUpgrade` and product statuses.

Comprende el código generado

Sondea Pub/Sub de Google Play y la API de App Store Server en el backend

En dart-backend/lib/google_play_purchase_handler.dart, _pullMessageFromPubSub sondea la suscripción projects/$googleCloudProjectId/subscriptions/$googlePlayPubsubBillingTopic-sub cada 10 segundos, decodifica cada carga útil de notificación en base64, vuelve a ejecutar handleSubscription o handleNonSubscription para actualizar Firestore y confirma el mensaje con _ackMessage:

  Future<void> _pullMessageFromPubSub() async {
    print('Polling Google Play messages');
    final request = pubsub.PullRequest(maxMessages: 1000);
    final topicName =
        'projects/$googleCloudProjectId/subscriptions/$googlePlayPubsubBillingTopic-sub';
    final pullResponse = await pubsubApi.projects.subscriptions.pull(
      request,
      topicName,
    );
    final messages = pullResponse.receivedMessages ?? [];
    for (final message in messages) {
      final data64 = message.message?.data;
      if (data64 != null) {
        await _processMessage(data64, message.ackId);
      }
    }
  }

Del mismo modo, en dart-backend/lib/app_store_purchase_handler.dart, _pullStatus consulta appStoreServerAPI.getAllSubscriptionStatuses(purchase.orderId) cada 10 segundos y actualiza expiryDate y SubscriptionStatus (active o expired) de cada suscripción en Cloud Firestore.

Sincroniza las compras de Firestore en el dispositivo

En app/lib/repo/iap_repo.dart, IAPRepo escucha los documentos purchases del usuario autenticado en Cloud Firestore en tiempo real y calcula hasActiveSubscription y hasUpgrade:

    var purchaseStream = _firestore
        .collection('purchases')
        .where('userId', isEqualTo: user.uid)
        .snapshots();
    _purchaseSubscription = purchaseStream.listen((snapshot) {
      purchases = snapshot.docs.map((document) {
        var data = document.data();
        return PastPurchase.fromJson(data);
      }).toList();

      hasActiveSubscription = purchases.any(
        (element) =>
            element.productId == storeKeySubscription &&
            element.status != Status.expired,
      );

      hasUpgrade = purchases.any(
        (element) => element.productId == storeKeyUpgrade,
      );

      notifyListeners();
    });

Cada vez que IAPRepo notifica a sus objetos de escucha, DashPurchases.purchasesUpdate() en app/lib/logic/dash_purchases.dart habilita o inhabilita el multiplicador de clics de 10x, activa o desactiva _beautifiedDashUpgrade y actualiza los estados de los productos que se muestran en PurchasePage:

  void purchasesUpdate() {
    var subscriptions = <PurchasableProduct>[];
    var upgrades = <PurchasableProduct>[];
    if (products.isNotEmpty) {
      subscriptions = products
          .where((element) => element.productDetails.id == storeKeySubscription)
          .toList();
      upgrades = products
          .where((element) => element.productDetails.id == storeKeyUpgrade)
          .toList();
    }

    if (iapRepo.hasActiveSubscription) {
      counter.applyPaidMultiplier();
      for (var element in subscriptions) {
        _updateStatus(element, ProductStatus.purchased);
      }
    } else {
      counter.removePaidMultiplier();
      for (var element in subscriptions) {
        _updateStatus(element, ProductStatus.purchasable);
      }
    }

    if (iapRepo.hasUpgrade != _beautifiedDashUpgrade) {
      _beautifiedDashUpgrade = iapRepo.hasUpgrade;
      for (var element in upgrades) {
        _updateStatus(
          element,
          _beautifiedDashUpgrade
              ? ProductStatus.purchased
              : ProductStatus.purchasable,
        );
      }
      notifyListeners();
    }
  }

  void _updateStatus(PurchasableProduct product, ProductStatus status) {
    if (product.status != status) {
      product.status = status;
      notifyListeners();
    }
  }

Ejecuta y prueba la app y el backend

Ejecuta las pruebas de unidades y widgets en ambos proyectos para verificar que todo se analice y se apruebe sin problemas:

cd dart-backend
dart test
cd ../app
flutter test

12. ¡Felicitaciones!

¡Felicitaciones! Colaboraste con Google Antigravity para crear una integración de compras directas desde la app de pila completa en Flutter con un backend de verificación de Dart.

Qué compilaste

  • Configuraste productos consumibles (dash_consumable_2k), no consumibles (dash_upgrade_3d) y de suscripción con renovación automática (dash_subscription_doubler) en App Store Connect y Google Play Console.
  • Conectaste la app de Flutter Dash Clicker (app/) al complemento in_app_purchase, consultaste los detalles del producto y escuchaste purchaseStream.
  • Se creó un backend de Dart shelf (dart-backend/) que verifica los tokens de compra con la API de Google Play Android Developer y la tienda de aplicaciones, sondea las actualizaciones de facturación con Cloud Pub/Sub y la API de App Store Server, y conserva el estado de compra en Cloud Firestore.
  • Sincroniza los derechos de compra verificados con el cliente de Flutter en tiempo real con IAPRepo.

Próximos pasos

  • Agrega el middleware de verificación de tokens de ID de Firebase Auth a POST /verifypurchase en dart-backend/bin/server.dart.
  • Implementa dart-backend/ en Cloud Run y configura webhooks de envío para Google Cloud Pub/Sub y las notificaciones del servidor de la tienda de aplicaciones.

Más información