1. Introduction
Pour ajouter des achats via une application à une application Flutter, vous devez configurer l'App Store d'Apple et le Google Play Store, valider les jetons d'achat sur un backend de confiance et accorder des droits tels que des devises consommables, des mises à niveau ponctuelles ou des avantages d'abonnement récurrents.
Dans cet atelier de programmation, vous allez collaborer avec Google Antigravity pour créer Dash Clicker, un jeu mobile de type clicker qui utilise la mascotte Dash comme monnaie. Vous l'associerez à un service de backend Dart shelf et à Cloud Firestore pour valider et suivre trois types d'achats via l'application :
- Consommable (
dash_consumable_2k) : achat répétable qui accorde immédiatement 2 000 Dashes au joueur et qui peut être acheté plusieurs fois. - Non consommable (
dash_upgrade_3d) : une mise à niveau permanente et unique qui transforme définitivement la mascotte Dash classique en une mascotte Dash 3D moderne. - Abonnement (
dash_subscription_doubler) : abonnement à renouvellement automatique qui multiplie les clics générés passivement tant que l'abonnement reste actif.
|
|
|
Ce que vous allez faire
- Une application mobile Flutter (
app/) stylisée avecmaterial_uietcupertino_uiqui interroge les produits de la boutique, lance des achats et réagit aux flux d'achats en temps réel. - Un serveur backend Dart
shelf(dart-backend/) qui valide les reçus d'achat auprès de Google Play et du magasin d'applications, interroge les événements de facturation du magasin et enregistre les états d'achat dans Cloud Firestore.
Votre parcours d'apprentissage
Cet atelier de programmation vous guide pas à pas dans la création et la connexion du parcours d'achat via une application full stack :
- Configurer l'environnement de développement : installez Flutter et Google Antigravity, demandez à Antigravity de créer le projet de démarrage Dash Clicker (
app/), puis configurez l'identifiant de votre bundle iOS et l'applicationIdAndroid. - Installer le plug-in : demandez à Antigravity d'ajouter
in_app_purchaseetin_app_purchase_platform_interfaceàapp/. - Configurer l'App Store : enregistrez votre ID d'application, créez un compte de test sandbox et configurez les trois produits dans App Store Connect.
- Configurer le Play Store : créez votre application dans la Google Play Console, demandez à Antigravity de configurer la signature du keystore de release dans Gradle, importez un app bundle initial, ajoutez des testeurs de licence et configurez les produits.
- Configurer Firebase : activez Google Sign-In et Cloud Firestore dans la console Firebase, exécutez
flutterfire configure, puis configurez les empreintes SHA-1 Android et les schémas d'URL iOS. - Écouter les mises à jour d'achats : demandez à Antigravity d'ajouter un wrapper
IAPConnectiontestable, abonnez-vous àpurchaseStreamet testez l'application avecTestIAPConnection. - Effectuer des achats : demandez à Antigravity d'encapsuler
ProductDetailsdansPurchasableProduct, d'interroger les produits du magasin, de déclencherbuyConsumableetbuyNonConsumable, et de finaliser les achats en attente. - Configurer le backend : demandez à Antigravity de créer l'infrastructure du serveur
dart-backend/avecIapRepositoryet de configurer les identifiants du compte de service. - Vérifier les achats : demandez à Antigravity d'exiger une connexion Firebase sur
PurchasePage, de publier des jetons d'achat sur/verifypurchase, et d'implémenterGooglePlayPurchaseHandleretAppStorePurchaseHandler. - Suivre les achats : demandez à Antigravity d'interroger Google Cloud Pub/Sub et l'API App Store Server sur le backend, puis de synchroniser les droits d'accès avec le client Flutter à l'aide de
IAPRepo.
Points abordés
- Comment collaborer avec Google Antigravity pour créer et personnaliser de manière itérative une application Flutter d'achat via une application full-stack et un backend Dart.
- Comment configurer App Store Connect et la Google Play Console avec des produits consommables, non consommables et sur abonnement.
- Comment interroger des produits, lancer des achats et gérer les flux d'achat avec le plug-in
in_app_purchase. - Comment valider les jetons d'achat Google Play et magasin d'applications sur un backend Dart et les stocker dans Cloud Firestore.
- Traiter les événements de facturation du magasin, et synchroniser les droits d'abonnement et de mise à niveau sur tous les appareils
Prérequis
- Connaissances de base des widgets Flutter, de la syntaxe Dart et de la gestion des états
Provider. - Un compte de développeur Apple (pour tester les achats sur l'App Store sur iOS), un compte de développeur Google Play (pour tester les achats sur le Play Store sur Android) ou les deux.
- Un compte Firebase et la CLI Firebase.
2. Configurer l'environnement de développement
Éditeur
Cet atelier de programmation utilise Google Antigravity comme environnement de développement axé sur l'IA. À chaque étape, vous demandez à Antigravity de générer ou de faire évoluer votre client Flutter (app/) et votre backend Dart (dart-backend/), d'inspecter le code généré et, si vous le souhaitez, d'explorer des variantes.
Installer Flutter
Les dernières instructions pour installer le SDK Flutter sont toujours disponibles sur docs.flutter.dev.
Pour cet atelier de programmation, installez les logiciels suivants :
- SDK Flutter
- Google Antigravity avec le plug-in Dart et Flutter officiel activé (disponible sur la place de marché des plug-ins dans la section Build with Google).
- Logiciel de compilation pour la cible mobile choisie (Android Studio pour Android ou Xcode pour iOS).
Demander à Antigravity de créer le projet de démarrage
- Lancez Google Antigravity et ouvrez un répertoire d'espace de travail vide dans lequel vous souhaitez créer votre application Flutter (
app/) et votre serveur Dart (dart-backend/). Choisissez un chemin d'accès qui ne nécessite pas de droits élevés ou qui ne contient pas d'espaces, comme un dossier dans votre répertoire d'accueil ouC:\src\. - Dans le panneau Discussion de l'agent Antigravity, envoyez le prompt suivant pour créer l'application de démarrage Dash Clicker dans
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')`.
Comprendre le code de démarrage généré
Antigravity crée le projet Flutter app/ et structure l'architecture du jeu Dash Clicker à l'aide de Provider et ChangeNotifier :
app/lib/main.dartenregistre cinqChangeNotifierProvider(FirebaseNotifier,DashCounter,DashUpgrades,IAPRepoetDashPurchases) dansMyHomePageet bascule entreHomePageetPurchasePage.app/lib/constants.dartdéfinit les trois ID produit de la plate-forme de téléchargement qui doivent correspondre aux ID que vous configurez dans App Store Connect et la 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';
Configurer l'identifiant du bundle et l'ID d'application de votre application
Pour communiquer avec l'App Store et le Play Store, votre application a besoin d'un identifiant de domaine inversé unique (par exemple, dev.flutter.dashclicker). Sur iOS, il s'agit de l'identifiant du bundle. Sur Android, il s'agit de l'ID d'application. L'utilisation du même identifiant sur les deux plates-formes simplifie la configuration.
Commencez par configurer l'identifiant du bundle pour iOS en ouvrant app/ios/Runner.xcworkspace dans Xcode :

Dans le navigateur de projets de Xcode, sélectionnez Runner en haut, ouvrez l'onglet Signing & Capabilities (Signature et fonctionnalités), sélectionnez votre équipe, puis saisissez votre identifiant du bundle unique :

Ensuite, mettez à jour l'applicationId Android dans app/android/app/build.gradle.kts pour qu'il corresponde à l'identifiant que vous avez choisi (vous pouvez le modifier directement ou demander à Antigravity de mettre à jour l'applicationId dans app/android/app/build.gradle.kts avec l'ID que vous avez choisi) :

3. Installer le plug-in
Dans cette étape, vous allez demander à Antigravity d'ajouter le plug-in in_app_purchase et son package d'interface de plate-forme (utilisé pour simuler les connexions au magasin dans les tests de widgets) à app/.
Demander à Antigravity d'installer in_app_purchase
Dans le panneau Discussion de l'agent Antigravity, envoyez le prompt suivant :
In `app/`, add `in_app_purchase` to `dependencies` and `in_app_purchase_platform_interface` to `dev_dependencies` in `pubspec.yaml`.
Comprendre le code généré
Antigravity exécute flutter pub add in_app_purchase dev:in_app_purchase_platform_interface dans app/, en mettant à jour 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_purchasefournit l'API multiplate-formeInAppPurchase, qui s'appuie sur StoreKit sur iOS et sur Google Play Billing sur Android.in_app_purchase_platform_interfaceexposeInAppPurchasePlatformAddition, qui vous permet d'implémenter un clientInAppPurchasefictif dansapp/test/widget_test.dart.
4. Configurer l'App Store
Pour tester les achats via une application sur iOS, vous devez enregistrer votre application dans App Store Connect et configurer les produits disponibles à l'achat. Vous n'avez pas besoin de publier l'application ni de l'envoyer pour examen, mais vous devez disposer d'un compte de développeur Apple. Si vous n'en avez pas, inscrivez-vous au programme pour les développeurs Apple.
Contrats d'applications payantes
Pour utiliser les achats via une application, vous devez disposer d'un contrat Paid Apps (Applications payantes) actif dans App Store Connect. Accédez à App Store Connect, puis sélectionnez Agreements, Tax, and Banking (Contrats, taxes et opérations bancaires) ou Business (Entreprise).

Examinez les contrats pour les applications sans frais et payantes. Consultez et acceptez les conditions d'utilisation des applications payantes, puis saisissez les informations fiscales et bancaires requises.

Une fois la configuration terminée, l'état de Applications payantes passe à Actif. Sans contrat d'applications payantes actif, StoreKit ne renverra pas vos produits intégrés lors des tests.

Enregistrer un ID d'application
Créez un ID d'application dans le portail des développeurs Apple :
- Accédez à la page Apple Developer Identifiers (Identifiants Apple Developer), puis cliquez sur l'icône + à côté de l'en-tête Identifiers (Identifiants).

- Sélectionnez App IDs (ID d'application), puis cliquez sur Continue (Continuer).

- Sélectionnez le type Application, puis cliquez sur Continuer.

- Saisissez une description et définissez l'ID du bundle (explicite) sur l'identifiant du bundle exact que vous avez configuré dans Xcode. Assurez-vous que la fonctionnalité In-App Purchase (Achat via une application) est activée, puis enregistrez l'identifiant.

Pour en savoir plus, consultez l'aide sur les comptes de développeur Apple.
Créer une application et un utilisateur de bac à sable
Créez une application dans App Store Connect à l'aide de l'identifiant de bundle enregistré :
|
|
Pour en savoir plus sur la création d'une application et la gestion des contrats, consultez l'aide d'App Store Connect.
Pour tester les achats via une application sans frais réels, créez un compte Apple Sandbox dans App Store Connect sous Users and Access > Sandbox (Utilisateurs et accès > Sandbox). Vous devez utiliser une adresse e-mail qui n'est pas déjà associée à un compte Apple.

Sur votre iPhone ou iPad de test, connectez-vous avec votre compte de bac à sable sous Réglages > Développeur > Compte Apple de bac à sable.
|
|
Configurer vos achats via l'application
Ensuite, configurez les trois articles achetables dans App Store Connect :
dash_consumable_2k: achat consommable qui peut être effectué plusieurs fois, octroyant 2 000 Dashes par achat.dash_upgrade_3d: achat d'une mise à niveau non consommable qui ne peut être achetée qu'une seule fois, débloquant la mascotte Dash 3D.dash_subscription_doubler: abonnement à renouvellement automatique qui multiplie les clics passifs lorsqu'il est actif.

Dans les sections Achats via une application (et Abonnements) de votre application, créez les trois produits avec les ID produit exacts suivants :
- Consommable (
dash_consumable_2k) :- Créez un produit Consommable avec le nom de référence
dash consumable 2ket l'ID produitdash_consumable_2k.
- Configurez la disponibilité de sorte que le produit soit disponible dans le pays ou la région de votre utilisateur de bac à sable.

- Définissez le prix sur
\$1.99(ou l'équivalent dans la devise locale).
- Ajoutez une localisation avec le nom à afficher
Spring is in the airet la description2000 dashes fly out.
- Importez une capture d'écran de l'avis. Le contenu de l'image n'a pas d'importance pour les tests en bac à sable, mais l'importation d'une capture d'écran fait passer le produit à l'état Prêt à être envoyé, ce qui est nécessaire pour que l'application récupère le produit depuis StoreKit.

- Créez un produit Consommable avec le nom de référence
- Non consommable (
dash_upgrade_3d) :- Créez un produit non consommable avec le nom de référence
dash upgrade 3det l'ID produitdash_upgrade_3d. - Définissez le nom à afficher sur
3D Dash, la description surBrings your dash back to the futureet le prix sur\$0.99. - Configurez la disponibilité et importez une capture d'écran de l'examen, comme vous l'avez fait pour
dash_consumable_2k.
- Créez un produit non consommable avec le nom de référence
- Abonnement à renouvellement automatique (
dash_subscription_doubler) :- Sous Abonnements, créez un groupe d'abonnements nommé
subscriptions(les utilisateurs ne peuvent s'abonner qu'à un seul produit d'un même groupe à la fois, et peuvent passer à un abonnement supérieur ou inférieur au sein du groupe).
- Ajoutez une localisation App Store pour le groupe d'abonnements.

- Dans le groupe, créez un abonnement avec le nom de référence
dash subscription doubleret l'ID produitdash_subscription_doubler.
- Définissez la durée de l'abonnement sur 1 semaine, le nom à afficher sur
Jet Engine, la description surDoubles your clickset le prix sur\$0.49. Configurez la disponibilité et importez une capture d'écran pour examen afin que l'état passe à Prêt à être envoyé.
- Sous Abonnements, créez un groupe d'abonnements nommé
Vos produits devraient maintenant apparaître dans App Store Connect avec l'état Prêt à être envoyé :


5. Configurer le Play Store
Pour tester les achats via une application sur Android, vous avez besoin d'un compte de développeur Google Play. Si vous n'avez pas encore de compte de développeur Google Play, créez-en un.
Créer une application
Créez une application dans la Google Play Console :
- Ouvrez la Google Play Console.
- Sélectionnez Toutes les applications > Créer une application.
- Choisissez une langue par défaut et saisissez le nom de l'application (vous pourrez le modifier ultérieurement).
- Sélectionnez Jeu comme type d'application et Sans frais comme modèle de tarification.
- Remplissez les déclarations Règlement du programme pour les développeurs et Lois des États-Unis en matière d'exportation, puis sélectionnez Créer une application.
Après avoir créé l'application, effectuez les tâches initiales de la section Configurer votre application du tableau de bord :

Signer l'application
Pour tester Google Play Billing, vous devez importer au moins une version signée appbundle dans un canal de test de la Google Play Console.
Créer un keystore
Si vous ne disposez pas encore d'un keystore d'importation, générez-en un à partir du terminal.
Sous macOS ou Linux :
keytool -genkey -v -keystore ~/key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias key
Sous Windows :
keytool -genkey -v -keystore c:\Users\USER_NAME\key.jks -storetype JKS -keyalg RSA -keysize 2048 -validity 10000 -alias key
Créer app/android/key.properties
Créez app/android/key.properties contenant une référence à votre keystore :
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>
Demander à Antigravity de configurer la signature de la version dans Gradle
Envoyez le prompt suivant dans Antigravity pour configurer la signature de la version dans 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 met à jour app/android/app/build.gradle.kts pour charger key.properties et signer les builds de production :
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")
}
}
}
Importer votre premier build
Créez un app bundle signé à partir de app/ :
cd app
flutter build appbundle
Le bundle de version est écrit dans app/build/app/outputs/bundle/release/app-release.aab.
Dans la Google Play Console, accédez à Tester et publier > Tests > Tests fermés, créez une version de test fermé, importez app-release.aab, puis cliquez sur Enregistrer > Vérifier la version > Lancer le déploiement pour les tests fermés.
Configurer des utilisateurs de test
Pour tester les achats via une application sur Android, ajoutez les comptes Google de vos testeurs à deux endroits dans la Google Play Console :
- Testeurs du canal de test : accédez à Tester et publier > Tests > Tests internes (ou Tests fermés), ouvrez l'onglet Testeurs, cliquez sur Créer une liste de diffusion, ajoutez les adresses e-mail de vos testeurs, sélectionnez la liste, puis cliquez sur Enregistrer les modifications.

- Testeurs de licence : revenez à la vue Toutes les applications, sélectionnez Paramètres > Test de licence, ajoutez les mêmes adresses e-mail de testeurs, définissez Réponse de licence sur
RESPOND_NORMALLY, puis cliquez sur Enregistrer les modifications.
Configurer vos achats via l'application
Configurez les trois mêmes ID produit dans la Google Play Console :
dash_consumable_2k: achat de consommable accordant 2 000 Dashes.dash_upgrade_3d: mise à niveau unique non consommable de 3D Dash.dash_subscription_doubler: abonnement à renouvellement automatique avec multiplicateur de clics.
Commencez par créer les produits ponctuels (dash_consumable_2k et dash_upgrade_3d) :
- Sélectionnez votre application dans la Google Play Console, puis accédez à Monétiser avec Play > Produits > Produits intégrés.
- Cliquez sur Créer un produit.

- Saisissez l'ID produit exact (
dash_consumable_2k), le nom, la description et le prix, puis cliquez sur Enregistrer et Activer. - Répétez l'opération pour
dash_upgrade_3d.
Ensuite, créez l'abonnement (dash_subscription_doubler) :
- Accédez à Monétiser avec Play > Produits > Abonnements, puis cliquez sur Créer un abonnement.

- Saisissez l'identifiant produit (
dash_subscription_doubler), ajoutez un forfait de base avec une période de facturation hebdomadaire et un prix, puis cliquez sur Enregistrer et Activer.
6. Configurer Firebase
L'utilisation d'un service de backend avec Cloud Firestore pour vérifier et suivre les achats offre plusieurs avantages en termes de sécurité à votre application :
- Vous validez les transactions directement auprès des serveurs Google Play et Apple.
- Vous pouvez réagir aux événements de facturation côté serveur (comme les renouvellements ou les annulations).
- Vous stockez une source unique de vérité dans Cloud Firestore associée à chaque utilisateur authentifié.
- Les utilisateurs ne peuvent pas débloquer les avantages premium en modifiant l'horloge de leur appareil.
Créer un projet Firebase
- Ouvrez la console Firebase et créez un projet Firebase (par exemple, Dash Clicker).
- Accédez à Build > Authentication (Compiler > Authentification), cliquez sur Get started (Commencer), ouvrez l'onglet Sign-in method (Méthode de connexion), puis activez le fournisseur de connexion Google.

- Accédez à Build > Firestore Database (Créer > Base de données Firestore) et créez une base de données.

- Ouvrez l'onglet Règles dans Cloud Firestore et publiez les règles de sécurité suivantes afin que les utilisateurs authentifiés ne puissent lire que leurs propres documents d'achat :
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
}
}
}
Configurer Firebase pour Flutter
Suivez le guide de configuration de FlutterFire pour installer la CLI FlutterFire, puis exécutez flutterfire configure dans app/ :
cd app
flutterfire configure
- Sélectionnez le projet Firebase que vous avez créé.
- Activez android et ios.
- Confirmez en saisissant yes lorsque vous êtes invité à remplacer
lib/firebase_options.dart.
Configurer Firebase pour Android : certificat SHA-1 de débogage
Pour utiliser Google Sign-In sur Android, vous devez enregistrer l'empreinte SHA-1 de votre keystore de débogage dans la console Firebase :
- Dans la console Firebase, accédez à Vue d'ensemble du projet > Paramètres du projet > Général, faites défiler la page jusqu'à Vos applications, puis sélectionnez votre application Android :

- Générez un rapport de signature à partir de
app/android/:cd app/android ./gradlew :app:signingReport - Recherchez l'empreinte
SHA1sousVariant: debugetConfig: debug, ajoutez-la à votre application Android dans la console Firebase, puis réexécutezflutterfire configuredansapp/pour quegoogle-services.jsonetlib/firebase_options.dartincluent la configuration du client OAuth mise à jour.
Configurer Firebase pour iOS : configurer des schémas d'URL
Pour prendre en charge Google Sign-In sur iOS, app/ios/Runner/Info.plist doit inclure le REVERSED_CLIENT_ID de app/ios/Runner/GoogleService-Info.plist dans CFBundleURLTypes (consultez la documentation sur l'intégration iOS de google_sign_in).
Vous pouvez demander à Antigravity de copier REVERSED_CLIENT_ID et CLIENT_ID de app/ios/Runner/GoogleService-Info.plist dans 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.
Dans app/ios/Runner/Info.plist, l'entrée CFBundleURLTypes se présente comme suit :
<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. Écouter les notifications sur les achats
Dans cette étape, vous allez préparer l'application Flutter à écouter les mises à jour des achats en magasin dès son lancement, et à maintenir l'arborescence des widgets testable en introduisant un wrapper IAPConnection remplaçable.
Demander à Antigravity d'écouter les mises à jour des achats
Envoyez le prompt suivant dans 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`.
Comprendre le code généré
Initialisation hâtive du fournisseur et IAPConnection dans app/lib/main.dart
Par défaut, Provider crée sa valeur de manière différée lorsqu'un widget la lit pour la première fois. Étant donné que les transactions en magasin en attente peuvent arriver sur purchaseStream immédiatement au démarrage, ChangeNotifierProvider définit lazy: false. De plus, IAPConnection fournit une jointure statique afin que les tests de widget puissent injecter une fausse implémentation de InAppPurchase :
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,
),
Abonnement à purchaseStream dans app/lib/logic/dash_purchases.dart
Dans DashPurchases, le constructeur s'abonne à iapConnection.purchaseStream et dispose() annule _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();
}
Exécuter et tester l'application
Exécutez la suite de tests de widgets dans app/ pour vérifier que TestIAPConnection simule correctement la connexion au magasin :
cd app
flutter test
8. Effectuer des achats
Au cours de cette étape, vous allez remplacer les produits fictifs codés en dur par des produits réels récupérés à l'aide de queryProductDetails, lancer des achats lorsque l'utilisateur appuie sur un produit et finaliser les transactions lorsque des mises à jour arrivent sur purchaseStream.
Demander à Antigravity de charger et d'effectuer des achats
Envoyez le prompt suivant dans 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.
Comprendre le code généré
Encapsulation de ProductDetails dans app/lib/model/purchasable_product.dart
PurchasableProduct encapsule l'élément ProductDetails renvoyé par le magasin tout en suivant l'élément ProductStatus de l'UI locale (purchasable, purchased ou 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;
}
Interrogation des produits dans app/lib/logic/dash_purchases.dart…
loadPurchases() vérifie d'abord que le magasin sous-jacent est accessible avec iapConnection.isAvailable(), puis interroge les trois ID produit définis dans 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();
}
Initier et finaliser des achats
Lorsqu'un utilisateur appuie sur un produit dans PurchasePage, buy() crée un PurchaseParam et envoie les produits consommables à buyConsumable, et les mises à niveau ponctuelles ou les abonnements à 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',
);
}
}
Lorsque le magasin émet des objets PurchaseDetails mis à jour sur purchaseStream, _handlePurchase accorde la récompense correspondante et confirme l'achèvement en appelant 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);
}
}
Exécuter et tester l'application
Exécutez flutter test dans app/ et lancez l'application sur votre appareil de test configuré. Lorsque les produits de votre boutique sont actifs, l'onglet Acheter les affiche comme étant prêts à l'achat :

9. Configurez le backend
Avant de valider et de suivre les achats sur un serveur, vous allez créer le service de backend Dart dans dart-backend/ avec app/, puis configurer les identifiants pour Firebase, Google Play et l'App Store.
Demander à Antigravity de créer le backend Dart
Dans le panneau Discussion de l'agent Antigravity, envoyez le prompt suivant pour créer le projet 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)`.
Comprendre le code généré
dart-backend/bin/server.dartinitialise unshelf_routerRouteret diffuse les requêtes HTTP sur le port8080à l'aide deserveHandlerdansdart-backend/lib/helpers.dart.dart-backend/lib/products.dartmappe chaque ID produit (dash_consumable_2k,dash_upgrade_3detdash_subscription_doubler) à sonProductType(nonSubscriptionousubscription).dart-backend/lib/iap_repository.dartencapsule la lecture et l'écriture des documentsNonSubscriptionPurchaseetSubscriptionPurchasedans la collectionpurchasesde Cloud Firestore à l'aide deFirestoreApi.
Vous pouvez vérifier que le serveur démarre localement en exécutant la commande suivante :
cd dart-backend
dart run ./bin/server.dart
Configurer l'accès à Firebase
Pour permettre à dart-backend/ d'écrire les achats validés dans Cloud Firestore, générez une clé de compte de service :
- Dans la console Firebase, ouvrez Paramètres du projet > Comptes de service, puis cliquez sur Générer une nouvelle clé privée.

- Enregistrez le fichier JSON téléchargé sous le nom
dart-backend/assets/service-account-firebase.json.
Configurer l'accès à Google Play
Pour permettre à dart-backend/ de valider les achats Android avec l'API Google Play Android Developer :
- Ouvrez la page de l'API Google Play Android Developer dans la console Google Cloud et activez l'API.

- Accédez à la page Comptes de service Google Cloud, puis cliquez sur + Créer un compte de service.

- Saisissez un nom de compte de service, puis cliquez sur Créer et continuer.

- Attribuez le rôle Abonné Pub/Sub, puis cliquez sur OK.

- Ouvrez le menu d'actions du compte de service que vous venez de créer, puis sélectionnez Gérer les clés.

- Sélectionnez Ajouter une clé > Créer une clé, choisissez JSON, puis téléchargez la clé :


- Enregistrez le fichier téléchargé sous le nom
dart-backend/assets/service-account-google-play.json. - Ouvrez Utilisateurs et autorisations dans la Google Play Console, cliquez sur Inviter de nouveaux utilisateurs, puis saisissez l'adresse e-mail du compte de service :


- Accordez les autorisations Afficher les données financières et Gérer les commandes et les abonnements pour votre application, puis cliquez sur Inviter un utilisateur.

Configurer l'accès à l'App Store d'Apple
Pour valider les reçus de l'App Store sur le backend, générez un secret partagé spécifique à l'application :
- Ouvrez App Store Connect, sélectionnez Apps, puis choisissez votre application.
- Dans la barre latérale, accédez à Général > Informations sur l'application.
- Sous Secret partagé spécifique à l'application, cliquez sur Gérer, générez un nouveau secret partagé, puis copiez-le :


Mettre à jour dart-backend/lib/constants.dart
Assurez-vous que les constantes suivantes sont définies dans dart-backend/lib/constants.dart :
androidPackageId: votreapplicationIdAndroid (par exemple,com.example.dashclicker).appStoreSharedSecret: votre secret partagé App Store Connect.bundleId: identifiant de votre bundle iOS (par exemple,com.example.dashclicker).
10. Valider les achats
Lorsqu'un utilisateur effectue un achat sur iOS ou Android, le magasin d'applications émet un jeton de validation (PurchaseDetails.verificationData.serverVerificationData). Au lieu de faire confiance directement à l'appareil client, l'application Flutter envoie ce jeton à dart-backend/, qui le valide auprès de Google Play ou de l'App Store et enregistre l'achat dans Cloud Firestore.

Demander à Antigravity de valider les achats sur le client et le backend
Envoyez le prompt suivant dans Antigravity pour connecter l'application Flutter et le flux de validation du backend 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.
Comprendre le code généré
Limiter les achats à l'authentification et appeler /verifypurchase
Dans app/lib/pages/purchase_page.dart, PurchasePage vérifie FirebaseNotifier et affiche LoginPage jusqu'à ce que l'utilisateur se connecte :
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();
}
Dans app/lib/logic/dash_purchases.dart, _verifyPurchase publie la source du magasin (google_play ou app_store), productID, serverVerificationData et l'userId connecté au backend Dart avant que _handlePurchase n'accorde la récompense dans l'application :
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;
}
}
Routage et correspondance de modèles Dart 3 dans dart-backend/bin/server.dart
Sur le serveur, POST /verifypurchase décode le corps de la requête JSON avec getPurchaseData à l'aide d'un motif de map Dart 3 et d'un type renvoyé d'enregistrement, puis délègue la validation au gestionnaire de magasin correspondant :
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');
}
}
Valider les reçus Google Play et App Store
- Dans
dart-backend/lib/google_play_purchase_handler.dart,GooglePlayPurchaseHandlerinterrogeandroidPublisher.purchases.products.getpour les produits ponctuels etandroidPublisher.purchases.subscriptions.getpour les abonnements, supprime les suffixes de renouvellement..#des ID de commande d'abonnement à l'aide deextractOrderId, puis écrit leNonSubscriptionPurchaseou leSubscriptionPurchaseobtenu dans Cloud Firestore à l'aide deiapRepository. - Dans
dart-backend/lib/app_store_purchase_handler.dart,AppStorePurchaseHandlerappelle_iTunesAPI.verifyReceiptà l'aide du packageapp_store_server_sdket conserve chaque reçu validé dansresponse.latestReceiptInfodans Cloud Firestore.
Exécuter et tester le backend
Démarrez le serveur backend à partir de dart-backend/ :
cd dart-backend
dart run bin/server.dart
11. Suivre les achats
Les abonnements peuvent être renouvelés, expirer ou être résiliés en dehors de votre application. Dans cette étape, vous allez configurer le backend pour interroger les mises à jour de facturation du magasin d'applications à partir de Google Cloud Pub/Sub et de l'API App Store Server, et mettre à jour le client Flutter pour synchroniser de manière réactive les droits d'accès actifs de l'utilisateur à partir de Cloud Firestore à l'aide de IAPRepo.
Configurer les clés API Cloud Pub/Sub et App Store Server
Configuration de Google Play Cloud Pub/Sub
- Définissez
googleCloudProjectIddansdart-backend/lib/constants.dartsur l'ID de votre projet Google Cloud et Firebase. - Ouvrez la page Sujets Cloud Pub/Sub dans la console Google Cloud, vérifiez que votre projet est sélectionné, puis cliquez sur + Créer un sujet.

- Définissez l'ID du sujet sur
play_billing(correspondant àgooglePlayPubsubBillingTopicdansdart-backend/lib/constants.dart, ce qui crée automatiquement un abonnement par défautplay_billing-sub), puis cliquez sur Créer.
- Ouvrez le menu à trois points de votre sujet
play_billing, puis sélectionnez Afficher les autorisations.
- Cliquez sur Ajouter un compte principal, saisissez
google-play-developer-notifications@system.gserviceaccount.com, attribuez le rôle Éditeur Pub/Sub, puis cliquez sur Enregistrer.
- Copiez le nom complet du sujet, ouvrez votre application dans la Google Play Console, accédez à Monétiser avec Play > Configuration de la monétisation, collez le nom du sujet, puis cliquez sur Enregistrer les modifications.

Configuration de la clé API App Store Server
- Connectez-vous à App Store Connect, puis sélectionnez Users and Access (Utilisateurs et accès).
- Accédez à Integrations > Keys > In-App Purchase (Intégrations > Clés > Achats via une application), puis cliquez sur le bouton + pour générer une clé (par exemple,
Codelab key). - Téléchargez le fichier de clé
.p8et enregistrez-le sous le nomdart-backend/assets/SubscriptionKey.p8. - Copiez l'ID de clé et l'ID d'émetteur dans
appStoreKeyIdetappStoreIssuerIddansdart-backend/lib/constants.dart.

Demander à Antigravity d'interroger les événements du magasin et de synchroniser l'état du client
Envoyez le prompt suivant dans 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.
Comprendre le code généré
Interroger Google Play Pub/Sub et l'API App Store Server sur le backend
Dans dart-backend/lib/google_play_purchase_handler.dart, _pullMessageFromPubSub interroge l'abonnement projects/$googleCloudProjectId/subscriptions/$googlePlayPubsubBillingTopic-sub toutes les 10 secondes, décode chaque charge utile de notification en base64, réexécute handleSubscription ou handleNonSubscription pour actualiser Firestore, et accuse réception du message à l'aide de _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);
}
}
}
De même, dans dart-backend/lib/app_store_purchase_handler.dart, _pullStatus interroge appStoreServerAPI.getAllSubscriptionStatuses(purchase.orderId) toutes les 10 secondes et met à jour les champs expiryDate et SubscriptionStatus (active ou expired) de chaque abonnement dans Cloud Firestore.
Synchronisation des achats Firestore sur l'appareil…
Dans app/lib/repo/iap_repo.dart, IAPRepo écoute les documents purchases de l'utilisateur authentifié dans Cloud Firestore en temps réel, et calcule hasActiveSubscription et 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();
});
Chaque fois que IAPRepo envoie une notification à ses écouteurs, DashPurchases.purchasesUpdate() dans app/lib/logic/dash_purchases.dart active ou désactive le multiplicateur de clics x10, active ou désactive _beautifiedDashUpgrade, et met à jour les états des produits affichés sur 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();
}
}
Exécuter et tester l'application et le backend
Exécutez les tests unitaires et de widgets sur les deux projets pour vérifier que tout est analysé et validé correctement :
cd dart-backend
dart test
cd ../app
flutter test
12. Félicitations
Félicitations ! Vous avez collaboré avec Google Antigravity pour créer une intégration full-stack des achats via une application dans Flutter avec un backend de validation Dart.
Ce que vous avez créé
- Vous avez configuré des produits consommables (
dash_consumable_2k), non consommables (dash_upgrade_3d) et des produits sur abonnement à renouvellement automatique (dash_subscription_doubler) dans App Store Connect et la Google Play Console. - Vous avez connecté l'application Flutter Dash Clicker (
app/) au plug-inin_app_purchase, interrogé les informations détaillées sur les produits et écoutépurchaseStream. - Création d'un backend Dart
shelf(dart-backend/) qui valide les jetons d'achat avec l'API Google Play Android Developer et le magasin d'applications, interroge les mises à jour de facturation à l'aide de Cloud Pub/Sub et de l'API App Store Server, et conserve l'état d'achat dans Cloud Firestore. - Synchronisez les droits d'achat validés avec le client Flutter en temps réel à l'aide de
IAPRepo.
Étapes suivantes
- Ajoutez le middleware de validation des jetons d'ID Firebase Auth à
POST /verifypurchasedansdart-backend/bin/server.dart. - Déployez
dart-backend/sur Cloud Run et configurez des webhooks push pour Google Cloud Pub/Sub et les notifications du serveur App Store.






