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:
- Consumible (
dash_consumable_2k): Es una compra repetible que otorga de inmediato 2,000 Dashes al jugador y se puede comprar varias veces. - 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. - 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.
|
|
|
Qué compilarás
- Una app para dispositivos móviles de Flutter (
app/) con diseño dematerial_uiycupertino_uique 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:
- 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 elapplicationIdde Android. - Instala el complemento: Pídele a Antigravity que agregue
in_app_purchaseyin_app_purchase_platform_interfaceaapp/. - 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.
- 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.
- Configura Firebase: Habilita Acceso con Google y Cloud Firestore en Firebase console, ejecuta
flutterfire configurey configura las huellas digitales SHA-1 de Android y los esquemas de URL de iOS. - Escucha las actualizaciones de compras: Solicita a Antigravity que agregue un wrapper de
IAPConnectionque se pueda probar, suscríbete apurchaseStreamy prueba la app conTestIAPConnection. - Realiza compras: Indica a Antigravity que una
ProductDetailsenPurchasableProduct, consulte los productos de la tienda, activebuyConsumableybuyNonConsumable, y complete las compras pendientes. - Configura el backend: Pídele a Antigravity que cree la estructura del servidor de
dart-backend/conIapRepositoryy configure las credenciales de la cuenta de servicio. - Verifica las compras: Indica a Antigravity que exija el acceso a Firebase en
PurchasePage, que publique tokens de compra en/verifypurchasey que implementeGooglePlayPurchaseHandleryAppStorePurchaseHandler. - 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:
- El SDK de Flutter
- Google Antigravity con el complemento oficial de Dart y Flutter habilitado (disponible en el Marketplace de complementos en la sección Build with Google)
- 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
- 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 oC:\src\. - 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.dartregistra cincoChangeNotifierProvider(FirebaseNotifier,DashCounter,DashUpgrades,IAPRepoyDashPurchases) dentro deMyHomePagey cambia entreHomePageyPurchasePage.app/lib/constants.dartdefine 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:

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:

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):

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_purchaseproporciona la API multiplataforma deInAppPurchaserespaldada por StoreKit en iOS y Facturación Google Play en Android.in_app_purchase_platform_interfaceexponeInAppPurchasePlatformAddition, que te permite implementar un clienteInAppPurchasesimulado enapp/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.
Acuerdos de Aplicaciones Pagadas
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).

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.

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.

Registra un ID de app
Crea un ID de app nuevo en el portal para desarrolladores de Apple:
- Visita Apple Developer Identifiers y haz clic en el ícono + junto al encabezado Identifiers.

- Selecciona App IDs y haz clic en Continue.

- Selecciona Aplicación como el tipo y haz clic en Continuar.

- 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.

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:
|
|
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.

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.
|
|
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.

En las secciones Compras directas desde la app (y Suscripciones) de tu app, crea los tres productos con estos IDs de producto exactos:
- Consumible (
dash_consumable_2k):- Crea un producto Consumible con el nombre de referencia
dash consumable 2ky el ID del productodash_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.

- Establece el precio en
\$1.99(o el equivalente en la moneda local).
- Agrega una localización con el nombre visible
Spring is in the airy la descripción2000 dashes fly out.
- 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.

- Crea un producto Consumible con el nombre de referencia
- No consumible (
dash_upgrade_3d):- Crea un producto no consumible con el nombre de referencia
dash upgrade 3dy el ID de productodash_upgrade_3d. - Establece el nombre visible en
3D Dash, la descripción enBrings your dash back to the futurey 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.
- Crea un producto no consumible con el nombre de referencia
- 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).
- Agrega una 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 doublery el ID del productodash_subscription_doubler.
- Establece la duración de la suscripción en 1 semana, el nombre visible en
Jet Engine, la descripción enDoubles your clicksy 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.
- En Suscripciones, crea un grupo de suscripciones llamado
Tus productos deberían aparecer en App Store Connect con el estado Ready to Submit:


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:
- Abre Google Play Console.
- Selecciona Todas las apps > Crear app.
- Elige un idioma predeterminado y, luego, ingresa un nombre para la app (puedes cambiarlo más adelante).
- Selecciona Juego como el tipo de app y Gratis como el modelo de precios.
- 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:

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:
- 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.

- 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_NORMALLYy haz clic en Guardar cambios.
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):
- Selecciona tu app en Google Play Console y navega a Monetiza con Play > Productos > Productos integrados en la aplicación.
- Haz clic en Crear producto.

- 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. - Repite el proceso para
dash_upgrade_3d.
A continuación, crea la suscripción (dash_subscription_doubler):
- Navega a Monetiza con Play > Productos > Suscripciones y haz clic en Crear suscripción.

- 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
- Abre Firebase console y crea un proyecto de Firebase nuevo (por ejemplo, Dash Clicker).
- 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.

- Navega a Compilación > Base de datos de Firestore y crea una base de datos.

- 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
- Selecciona el proyecto de Firebase que creaste.
- Habilita android y ios.
- 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:
- 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:

- Genera un informe de firma desde
app/android/:cd app/android ./gradlew :app:signingReport - Busca la huella digital
SHA1enVariant: debugyConfig: debug, agrégala a tu app para Android en Firebase console y vuelve a ejecutarflutterfire configureenapp/para quegoogle-services.jsonylib/firebase_options.dartincluyan 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:

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.dartinicializa unRoutershelf_routery entrega solicitudes HTTP en el puerto8080conserveHandlerendart-backend/lib/helpers.dart.dart-backend/lib/products.dartasigna cada ID de producto (dash_consumable_2k,dash_upgrade_3dydash_subscription_doubler) a suProductType(nonSubscriptionosubscription).dart-backend/lib/iap_repository.dartencapsula la lectura y escritura de documentosNonSubscriptionPurchaseySubscriptionPurchaseen la colecciónpurchasesde Cloud Firestore conFirestoreApi.
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:
- En Firebase console, abre Configuración del proyecto > Cuentas de servicio y haz clic en Generar nueva clave privada.

- 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:
- Abre la página de la API de Google Play Android Developer en la consola de Google Cloud y habilita la API.

- Ve a la página Cuentas de servicio de Google Cloud y haz clic en + Crear cuenta de servicio.

- Ingresa un nombre para la cuenta de servicio y haz clic en Crear y continuar.

- Otorga el rol Suscriptor de Pub/Sub y haz clic en Listo.

- Abre el menú de acciones de la cuenta de servicio recién creada y selecciona Administrar claves.

- Selecciona Agregar clave > Crear clave nueva, elige JSON y descarga la clave:


- Guarda el archivo descargado como
dart-backend/assets/service-account-google-play.json. - 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:


- Otorga los permisos Ver los datos financieros y Administrar pedidos y suscripciones para tu app y, luego, haz clic en Invitar usuario.

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:
- Abre App Store Connect, selecciona Apps y elige tu app.
- En la barra lateral, navega a General > Información de la app.
- En Secreto compartido específico de la app, haz clic en Administrar, genera un nuevo secreto compartido y cópialo:


Actualizar dart-backend/lib/constants.dart
Asegúrate de que las siguientes constantes estén configuradas en dart-backend/lib/constants.dart:
androidPackageId: Es elapplicationIdde Android (comocom.example.dashclicker).appStoreSharedSecret: Es el secreto compartido de App Store Connect.bundleId: Es el identificador de paquete de iOS (comocom.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.

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,GooglePlayPurchaseHandlerconsultaandroidPublisher.purchases.products.getpara productos únicos yandroidPublisher.purchases.subscriptions.getpara suscripciones, quita los sufijos de renovación..#de los IDs de pedidos de suscripción conextractOrderIdy escribe elNonSubscriptionPurchaseoSubscriptionPurchaseresultante en Cloud Firestore coniapRepository. - En
dart-backend/lib/app_store_purchase_handler.dart,AppStorePurchaseHandlerllama a_iTunesAPI.verifyReceiptcon el paqueteapp_store_server_sdky conserva cada recibo verificado enresponse.latestReceiptInfoen 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
- Establece
googleCloudProjectIdendart-backend/lib/constants.dartcomo el ID de tu proyecto de Google Cloud y Firebase. - 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.

- Establece el ID del tema como
play_billing(que coincida congooglePlayPubsubBillingTopicendart-backend/lib/constants.dart, lo que crea automáticamente una suscripción predeterminadaplay_billing-sub) y haz clic en Crear.
- Abre el menú de tres puntos en tu tema
play_billingy selecciona Ver permisos.
- 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.
- 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 clave de la API de App Store Server
- Accede a App Store Connect y selecciona Users and Access.
- 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). - Descarga el archivo de claves
.p8y guárdalo comodart-backend/assets/SubscriptionKey.p8. - Copia el ID de clave y el ID de emisor en
appStoreKeyIdyappStoreIssuerIdendart-backend/lib/constants.dart.

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 complementoin_app_purchase, consultaste los detalles del producto y escuchastepurchaseStream. - 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 /verifypurchaseendart-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.






