Ajouter des achats via une application à votre application Flutter

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 :

  1. Consommable (dash_consumable_2k) : achat répétable qui accorde immédiatement 2 000 Dashes au joueur et qui peut être acheté plusieurs fois.
  2. 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.
  3. Abonnement (dash_subscription_doubler) : abonnement à renouvellement automatique qui multiplie les clics générés passivement tant que l'abonnement reste actif.

Écran d'accueil de Dash Clicker montrant la mascotte Dash classique et le compteur de clics

Écran d'achat de Dash Clicker listant les produits intégrés disponibles et les achats précédents

Écran d'accueil de Dash Clicker après l'achat de l'amélioration 3D Dash

Ce que vous allez faire

  • Une application mobile Flutter (app/) stylisée avec material_ui et cupertino_ui qui 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 :

  1. 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'applicationId Android.
  2. Installer le plug-in : demandez à Antigravity d'ajouter in_app_purchase et in_app_purchase_platform_interface à app/.
  3. 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.
  4. 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.
  5. 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.
  6. Écouter les mises à jour d'achats : demandez à Antigravity d'ajouter un wrapper IAPConnection testable, abonnez-vous à purchaseStream et testez l'application avec TestIAPConnection.
  7. Effectuer des achats : demandez à Antigravity d'encapsuler ProductDetails dans PurchasableProduct, d'interroger les produits du magasin, de déclencher buyConsumable et buyNonConsumable, et de finaliser les achats en attente.
  8. Configurer le backend : demandez à Antigravity de créer l'infrastructure du serveur dart-backend/ avec IapRepository et de configurer les identifiants du compte de service.
  9. Vérifier les achats : demandez à Antigravity d'exiger une connexion Firebase sur PurchasePage, de publier des jetons d'achat sur /verifypurchase, et d'implémenter GooglePlayPurchaseHandler et AppStorePurchaseHandler.
  10. 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 :

  1. SDK Flutter
  2. 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).
  3. 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

  1. 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 ou C:\src\.
  2. 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.dart enregistre cinq ChangeNotifierProvider (FirebaseNotifier, DashCounter, DashUpgrades, IAPRepo et DashPurchases) dans MyHomePage et bascule entre HomePage et PurchasePage.
  • app/lib/constants.dart dé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 :

Ouverture de 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 :

Configurer l'équipe et l'identifiant du bundle dans "Signing & Capabilities" (Signature et fonctionnalités) de Xcode

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

Définir applicationId dans android/app/build.gradle.kts

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_purchase fournit l'API multiplate-forme InAppPurchase, qui s'appuie sur StoreKit sur iOS et sur Google Play Billing sur Android.
  • in_app_purchase_platform_interface expose InAppPurchasePlatformAddition, qui vous permet d'implémenter un client InAppPurchase fictif dans app/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.

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

Tableau de bord de la page d'accueil d'App Store Connect mettant en évidence "Agreements, Tax, and Banking" (Contrats, taxes et coordonnées bancaires)

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.

Liste des contrats App Store Connect affichant les applications sans frais actives et les nouvelles applications payantes

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.

Liste des contrats App Store Connect montrant que les applications sans frais et payantes sont actives

Enregistrer un ID d'application

Créez un ID d'application dans le portail des développeurs Apple :

  1. 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).Liste des identifiants du portail des développeurs Apple avec le bouton d'ajout mis en évidence
  2. Sélectionnez App IDs (ID d'application), puis cliquez sur Continue (Continuer).Écran "Register a new identifier" (Enregistrer un nouvel identifiant) avec l'option "App IDs" (ID d'application) sélectionnée
  3. Sélectionnez le type Application, puis cliquez sur Continuer.Écran de sélection du type avec l'option "Application" sélectionnée
  4. 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.Formulaire "Register an App ID" (Enregistrer un ID d'application) affichant la description et l'ID du bundle explicite

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

Menu "Apps" d'App Store Connect affichant l'option "New App" (Nouvelle application)

Boîte de dialogue "New App" (Nouvelle application) dans App Store Connect affichant les champs "Platform" (Plate-forme), "Name" (Nom), "Language" (Langue), "Bundle ID" (ID du bundle) et "SKU" (Code SKU)

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.

Liste des testeurs de la sandbox App Store Connect

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.

Écran des paramètres iOS affichant la section "Compte Apple Sandbox"

Écran des paramètres iOS affichant un compte Apple Sandbox connecté

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.

Barre latérale d'App Store Connect mettant en évidence les achats via une application et les abonnements

Dans les sections Achats via une application (et Abonnements) de votre application, créez les trois produits avec les ID produit exacts suivants :

  1. Consommable (dash_consumable_2k) :
    • Créez un produit Consommable avec le nom de référence dash consumable 2k et l'ID produit dash_consumable_2k.Créer une boîte de dialogue d'achat via une application configurée pour dash_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.Configuration de la disponibilité pour l'achat via une application
    • Définissez le prix sur \$1.99 (ou l'équivalent dans la devise locale).Configuration de la grille tarifaire définie sur 1,99 $
    • Ajoutez une localisation avec le nom à afficher Spring is in the air et la description 2000 dashes fly out.Localisation du magasin d'applications affichant le nom à afficher et la description
    • 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.Section "Vérifier les informations" avec un aperçu de l'image du produit importée
  2. Non consommable (dash_upgrade_3d) :
    • Créez un produit non consommable avec le nom de référence dash upgrade 3d et l'ID produit dash_upgrade_3d.
    • Définissez le nom à afficher sur 3D Dash, la description sur Brings your dash back to the future et 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.Configuration du produit non consommable pour dash_upgrade_3d
  3. 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).Boîte de dialogue "Créer un groupe d'abonnements"
    • Ajoutez une localisation App Store pour le groupe d'abonnements.Boîte de dialogue de localisation du magasin d'applications pour le groupe d'abonnements
    • Dans le groupe, créez un abonnement avec le nom de référence dash subscription doubler et l'ID produit dash_subscription_doubler.Boîte de dialogue "Créer un abonnement" pour dash_subscription_doubler
    • Définissez la durée de l'abonnement sur 1 semaine, le nom à afficher sur Jet Engine, la description sur Doubles your clicks et 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é.Durée, prix et paramètres de localisation de l'abonnement

Vos produits devraient maintenant apparaître dans App Store Connect avec l'état Prêt à être envoyé :

Liste des achats via l'application affichant dash_consumable_2k et dash_upgrade_3d comme prêts à être envoyés

Liste des abonnements affichant dash_subscription_doubler comme "Prêt pour l'envoi"

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 :

  1. Ouvrez la Google Play Console.
  2. Sélectionnez Toutes les applications > Créer une application.
  3. Choisissez une langue par défaut et saisissez le nom de l'application (vous pourrez le modifier ultérieurement).
  4. Sélectionnez Jeu comme type d'application et Sans frais comme modèle de tarification.
  5. 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 :

Tableau de bord de la Google Play Console affichant la checklist "Configurer votre application"

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 :

  1. 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.Onglet &quot;Testeurs&quot; de la page &quot;Tests internes&quot; de la Google Play Console
  2. 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.Paramètres de test de licence de la Google Play Console

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

  1. Sélectionnez votre application dans la Google Play Console, puis accédez à Monétiser avec Play > Produits > Produits intégrés.
  2. Cliquez sur Créer un produit.Page &quot;Produits intégrés&quot; de la Google Play Console avec le bouton &quot;Créer un produit&quot;
  3. Saisissez l'ID produit exact (dash_consumable_2k), le nom, la description et le prix, puis cliquez sur Enregistrer et Activer.
  4. Répétez l'opération pour dash_upgrade_3d.

Ensuite, créez l'abonnement (dash_subscription_doubler) :

  1. Accédez à Monétiser avec Play > Produits > Abonnements, puis cliquez sur Créer un abonnement.Page &quot;Abonnements&quot; de la Google Play Console avec le bouton &quot;Créer un abonnement&quot;
  2. 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

  1. Ouvrez la console Firebase et créez un projet Firebase (par exemple, Dash Clicker).
  2. 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.Onglet &quot;Mode de connexion&quot; de Firebase Authentication montrant que Google est activé
  3. Accédez à Build > Firestore Database (Créer > Base de données Firestore) et créez une base de données.Bannière de création de Cloud Firestore dans la console Firebase
  4. 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
  1. Sélectionnez le projet Firebase que vous avez créé.
  2. Activez android et ios.
  3. 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 :

  1. 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 :Paramètres du projet Firebase affichant la configuration de l'application Android et le bouton &quot;Ajouter une empreinte&quot;
  2. Générez un rapport de signature à partir de app/android/ :
    cd app/android
    ./gradlew :app:signingReport
    
  3. Recherchez l'empreinte SHA1 sous Variant: debug et Config: debug, ajoutez-la à votre application Android dans la console Firebase, puis réexécutez flutterfire configure dans app/ pour que google-services.json et lib/firebase_options.dart incluent 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 :

Onglet &quot;Achat&quot; de Dash Clicker affichant les trois produits chargés depuis le magasin

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.dart initialise un shelf_router Router et diffuse les requêtes HTTP sur le port 8080 à l'aide de serveHandler dans dart-backend/lib/helpers.dart.
  • dart-backend/lib/products.dart mappe chaque ID produit (dash_consumable_2k, dash_upgrade_3d et dash_subscription_doubler) à son ProductType (nonSubscription ou subscription).
  • dart-backend/lib/iap_repository.dart encapsule la lecture et l'écriture des documents NonSubscriptionPurchase et SubscriptionPurchase dans la collection purchases de Cloud Firestore à l'aide de FirestoreApi.

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 :

  1. Dans la console Firebase, ouvrez Paramètres du projet > Comptes de service, puis cliquez sur Générer une nouvelle clé privée.Onglet &quot;Comptes de service&quot; des paramètres du projet Firebase, avec l'option &quot;Générer une nouvelle clé privée&quot;
  2. 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 :

  1. Ouvrez la page de l'API Google Play Android Developer dans la console Google Cloud et activez l'API.Page de la console Google Cloud pour l'API Google Play Android Developer
  2. Accédez à la page Comptes de service Google Cloud, puis cliquez sur + Créer un compte de service.Page &quot;Comptes de service&quot; de la console Google Cloud affichant l'option &quot;Créer un compte de service&quot;
  3. Saisissez un nom de compte de service, puis cliquez sur Créer et continuer.Étape des détails du compte de service
  4. Attribuez le rôle Abonné Pub/Sub, puis cliquez sur OK.Étape &quot;Autoriser ce compte de service à accéder au projet&quot; affichant le rôle &quot;Abonné Pub/Sub&quot;
  5. Ouvrez le menu d'actions du compte de service que vous venez de créer, puis sélectionnez Gérer les clés.Menu d'actions du compte de service mettant en évidence &quot;Gérer les clés&quot;
  6. Sélectionnez Ajouter une clé > Créer une clé, choisissez JSON, puis téléchargez la clé :Menu &quot;Ajouter une clé&quot; affichant &quot;Créer une clé&quot;Boîte de dialogue &quot;Créer une clé privée&quot; avec l'option JSON sélectionnée
  7. Enregistrez le fichier téléchargé sous le nom dart-backend/assets/service-account-google-play.json.
  8. 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 :Page &quot;Utilisateurs et autorisations&quot; de la Google Play ConsoleTableau des comptes de service Google Cloud affichant l'adresse e-mail du compte de service
  9. 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.Onglet &quot;Autorisations de l'application&quot; avec les options &quot;Afficher les données financières&quot; et &quot;Gérer les commandes et les abonnements&quot; cochées

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 :

  1. Ouvrez App Store Connect, sélectionnez Apps, puis choisissez votre application.
  2. Dans la barre latérale, accédez à Général > Informations sur l'application.
  3. Sous Secret partagé spécifique à l'application, cliquez sur Gérer, générez un nouveau secret partagé, puis copiez-le :Section &quot;Secret partagé spécifique à l'application&quot; d'App Store ConnectBoîte de dialogue &quot;Secret partagé spécifique à l'application&quot; affichant le secret généré

Mettre à jour dart-backend/lib/constants.dart

Assurez-vous que les constantes suivantes sont définies dans dart-backend/lib/constants.dart :

  • androidPackageId : votre applicationId Android (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.

Hiérarchie de la classe PurchaseHandler implémentée par GooglePlayPurchaseHandler et AppStorePurchaseHandler

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, GooglePlayPurchaseHandler interroge androidPublisher.purchases.products.get pour les produits ponctuels et androidPublisher.purchases.subscriptions.get pour les abonnements, supprime les suffixes de renouvellement ..# des ID de commande d'abonnement à l'aide de extractOrderId, puis écrit le NonSubscriptionPurchase ou le SubscriptionPurchase obtenu dans Cloud Firestore à l'aide de iapRepository.
  • Dans dart-backend/lib/app_store_purchase_handler.dart, AppStorePurchaseHandler appelle _iTunesAPI.verifyReceipt à l'aide du package app_store_server_sdk et conserve chaque reçu validé dans response.latestReceiptInfo dans 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

  1. Définissez googleCloudProjectId dans dart-backend/lib/constants.dart sur l'ID de votre projet Google Cloud et Firebase.
  2. 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.Page &quot;Sujets&quot; de Google Cloud Pub/Sub affichant le bouton &quot;Créer un sujet&quot;
  3. Définissez l'ID du sujet sur play_billing (correspondant à googlePlayPubsubBillingTopic dans dart-backend/lib/constants.dart, ce qui crée automatiquement un abonnement par défaut play_billing-sub), puis cliquez sur Créer.Boîte de dialogue &quot;Créer un sujet&quot; avec l'ID de sujet &quot;play_billing&quot;
  4. Ouvrez le menu à trois points de votre sujet play_billing, puis sélectionnez Afficher les autorisations.Menu du sujet Pub/Sub mettant en évidence les droits d'affichage
  5. 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.Panneau &quot;Ajouter des comptes principaux&quot; accordant le rôle &quot;Éditeur Pub/Sub&quot; à google-play-developer-notifications
  6. 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 monétisation dans la Google Play Console, affichant le nom du sujet des notifications en temps réel pour les développeurs

Configuration de la clé API App Store Server

  1. Connectez-vous à App Store Connect, puis sélectionnez Users and Access (Utilisateurs et accès).
  2. 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).
  3. Téléchargez le fichier de clé .p8 et enregistrez-le sous le nom dart-backend/assets/SubscriptionKey.p8.
  4. Copiez l'ID de clé et l'ID d'émetteur dans appStoreKeyId et appStoreIssuerId dans dart-backend/lib/constants.dart.

Liste des clés d'achat via l'application App Store Connect affichant l'ID de l'émetteur et l'ID de la clé

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-in in_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 /verifypurchase dans dart-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.

En savoir plus