1. Introdução
Para adicionar compras no app a um aplicativo Flutter, é necessário configurar a App Store da Apple e a Google Play Store, verificar os tokens de compra em um back-end confiável e conceder direitos, como moedas consumíveis, upgrades únicos ou benefícios de assinatura recorrentes.
Neste codelab, você vai colaborar com o Google Antigravity para criar o Dash Clicker, um jogo de cliques para dispositivos móveis que usa o mascote Dash como moeda, e pareá-lo com um serviço de back-end Dart shelf e o Cloud Firestore para validar e acompanhar três tipos de compras no app:
- Consumível (
dash_consumable_2k): uma compra repetível que concede imediatamente ao jogador 2.000 Dashes e pode ser comprada várias vezes. - Não consumível (
dash_upgrade_3d): um upgrade permanente que transforma o mascote clássico do Dash em um Dash 3D moderno para sempre. - Assinatura (
dash_subscription_doubler): uma assinatura com renovação automática que multiplica os cliques gerados passivamente enquanto ela permanece ativa.
|
|
|
O que você vai criar
- Um app para dispositivos móveis do Flutter (
app/) estilizado commaterial_uiecupertino_uique consulta produtos da loja, inicia compras e reage a streams de compra em tempo real. - Um servidor de back-end Dart
shelf(dart-backend/) que verifica os recibos de compra com o Google Play e a App Store, pesquisa eventos de faturamento da loja e registra os estados de compra no Cloud Firestore.
Sua jornada de aprendizado
Este codelab mostra como criar e conectar o fluxo de compra no app de pilha completa, passo a passo:
- Configurar o ambiente de desenvolvimento: instale o Flutter e o Google Antigravity, peça para o Antigravity criar o scaffolding do projeto inicial do Dash Clicker (
app/) e configure o identificador do pacote do iOS e oapplicationIddo Android. - Instalar o plug-in: peça para o Antigravity adicionar
in_app_purchaseein_app_purchase_platform_interfaceaapp/. - Configurar a App Store: registre o ID do app, crie uma conta de teste de sandbox e configure os três produtos no App Store Connect.
- Configurar a Play Store: crie seu app no Google Play Console, peça para o Antigravity configurar a assinatura do keystore de lançamento no Gradle, faça upload de um pacote de app inicial, adicione testadores de licença e configure os produtos.
- Configurar o Firebase: ative o Login do Google e o Cloud Firestore no console do Firebase, execute
flutterfire configuree configure as impressões digitais SHA-1 do Android e os esquemas de URL do iOS. - Detectar atualizações de compra: peça para o Antigravity adicionar um wrapper
IAPConnectiontestável, se inscrever empurchaseStreame testar o app comTestIAPConnection. - Fazer compras: peça para o Antigravity encapsular
ProductDetailsemPurchasableProduct, consultar produtos da loja, acionarbuyConsumableebuyNonConsumablee concluir compras pendentes. - Configurar o back-end: peça para o Antigravity criar o servidor
dart-backend/comIapRepositorye configurar as credenciais da conta de serviço. - Verificar compras: peça para o Antigravity exigir o login do Firebase em
PurchasePage, postar tokens de compra em/verifypurchasee implementarGooglePlayPurchaseHandlereAppStorePurchaseHandler. - Acompanhar compras: peça ao Antigravity para consultar o Google Cloud Pub/Sub e a API App Store Server no back-end e sincronizar os direitos de volta com o cliente do Flutter usando
IAPRepo.
O que você vai aprender
- Como colaborar com o Google Antigravity para criar e personalizar de forma iterativa um app de compra no app do Flutter de pilha completa e um back-end do Dart.
- Como configurar a App Store Connect e o Google Play Console com produtos consumíveis, não consumíveis e por assinatura.
- Como consultar produtos, iniciar compras e processar fluxos de compra com o plug-in
in_app_purchase. - Como verificar tokens de compra do Google Play e da App Store em um back-end do Dart e armazená-los no Cloud Firestore.
- Como processar eventos de faturamento da loja e sincronizar direitos de assinatura e upgrade em vários dispositivos.
Pré-requisitos
- Conhecimento básico sobre widgets do Flutter, sintaxe do Dart e gerenciamento de estado do
Provider. - Uma conta de desenvolvedor da Apple (para testar compras na App Store no iOS), uma conta de desenvolvedor do Google Play (para testar compras na Google Play Store no Android) ou ambas.
- Uma conta do Firebase e a CLI do Firebase.
2. Configurar o ambiente de desenvolvimento
Editor
Este codelab usa o Google Antigravity como seu ambiente de desenvolvimento focado em IA. Em cada etapa, você pede para o Antigravity gerar ou evoluir seu cliente do Flutter (app/) e o back-end do Dart (dart-backend/), inspeciona o código gerado e, se quiser, explora variações.
Instalar o Flutter
As instruções mais atualizadas sobre como instalar o SDK do Flutter estão sempre em docs.flutter.dev (link em inglês).
Para este codelab, instale os seguintes softwares:
- SDK do Flutter.
- O Google Antigravity com o plug-in oficial do Dart e do Flutter ativado (disponível no Marketplace de plug-ins na seção Build with Google).
- Software de compilador para a plataforma de destino escolhida (Android Studio para Android ou Xcode para iOS).
Pedir ao Antigravity para criar o projeto inicial
- Inicie o Google Antigravity e abra um diretório de espaço de trabalho vazio onde você quer criar o app Flutter (
app/) e o servidor Dart (dart-backend/). Escolha um caminho que não exija privilégios elevados nem contenha espaços, como uma pasta no diretório inicial ouC:\src\. - No painel de conversa do agente do Antigravity, envie o seguinte comando para criar o app inicial do Dash Clicker em
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')`.
Noções básicas sobre o código inicial gerado
O Antigravity cria o projeto do Flutter app/ e estrutura a arquitetura do jogo Dash Clicker usando Provider e ChangeNotifier:
app/lib/main.dartregistra cincoChangeNotifierProviders (FirebaseNotifier,DashCounter,DashUpgrades,IAPRepoeDashPurchases) dentro deMyHomePagee alterna entreHomePageePurchasePage.app/lib/constants.dartdefine os três IDs de produto da loja que precisam corresponder aos IDs configurados no App Store Connect e no 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';
Configurar o identificador do pacote e o ID do aplicativo
Para se comunicar com a App Store e a Google Play Store, seu app precisa de um identificador de domínio reverso exclusivo (por exemplo, dev.flutter.dashclicker). No iOS, ele é chamado de identificador do pacote. No Android, é o ID do aplicativo. Usar o mesmo identificador nas duas plataformas simplifica a configuração.
Primeiro, configure o identificador do pacote para iOS abrindo app/ios/Runner.xcworkspace no Xcode:

No navegador de projetos do Xcode, selecione Runner na parte de cima, abra a guia Signing & Capabilities, selecione sua Team e insira seu Bundle Identifier exclusivo:

Em seguida, atualize o applicationId do Android em app/android/app/build.gradle.kts para que ele corresponda ao identificador escolhido. Você pode editar diretamente ou pedir para o Antigravity atualizar o applicationId em app/android/app/build.gradle.kts para o ID escolhido:

3. Instalar o plug-in
Nesta etapa, você vai pedir para o Antigravity adicionar o plug-in in_app_purchase e o pacote de interface da plataforma (usado para simular conexões de loja em testes de widgets) ao app/.
Peça ao Antigravity para instalar o in_app_purchase
No painel de conversa do agente do Antigravity, envie o seguinte comando:
In `app/`, add `in_app_purchase` to `dependencies` and `in_app_purchase_platform_interface` to `dev_dependencies` in `pubspec.yaml`.
Noções básicas sobre o código gerado
O Antigravity executa flutter pub add in_app_purchase dev:in_app_purchase_platform_interface dentro de app/, atualizando 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
- O
in_app_purchasefornece a API multiplataformaInAppPurchase, que usa o StoreKit no iOS e o Google Play Faturamento no Android. in_app_purchase_platform_interfaceexpõeInAppPurchasePlatformAddition, que permite implementar um clienteInAppPurchasesimulado emapp/test/widget_test.dart.
4. Configurar a App Store
Para testar compras no app no iOS, registre seu app no App Store Connect e configure os produtos disponíveis para compra. Não é necessário publicar o app ou enviá-lo para revisão, mas você precisa de uma conta de desenvolvedor da Apple. Se você não tiver uma, inscreva-se no Apple Developer Program.
Contratos de apps pagos
Para usar compras no app, é necessário ter um contrato ativo de apps pagos no App Store Connect. Acesse o App Store Connect e selecione Agreements, Tax, and Banking (ou Business).

Revise os contratos de apps sem custo financeiro e pagos. Leia e aceite os termos para Apps pagos e insira as informações fiscais e bancárias necessárias.

Quando tudo estiver configurado, o status de Apps pagos vai mudar para Ativo. Sem um contrato de apps pagos ativo, o StoreKit não vai retornar seus produtos no app durante os testes.

Registrar um ID de app
Crie um novo ID do app no portal do desenvolvedor da Apple:
- Acesse Apple Developer Identifiers e clique no ícone + ao lado do cabeçalho Identifiers.

- Selecione IDs de apps e clique em Continuar.

- Selecione App como o tipo e clique em Continuar.

- Insira uma descrição e defina o ID do pacote (explícito) como o identificador exato que você configurou no Xcode. Verifique se o recurso Compra no app está ativado e registre o identificador.

Para mais detalhes, consulte a Ajuda da conta de desenvolvedor da Apple.
Criar um novo app e um usuário de sandbox
Crie um app no App Store Connect usando o identificador do pacote registrado:
|
|
Para mais orientações sobre como criar um app e gerenciar contratos, consulte a Ajuda do App Store Connect.
Para testar compras no app sem cobranças reais, crie uma Conta Apple de sandbox no App Store Connect em Usuários e acesso > Sandbox. Use um endereço de e-mail que ainda não esteja associado a uma Conta Apple.

No iPhone ou iPad de teste, faça login com sua conta de sandbox em Ajustes > Desenvolvedor > Conta da Apple de sandbox.
|
|
Configurar as compras no app
Em seguida, configure os três itens que podem ser comprados no App Store Connect:
dash_consumable_2k: uma compra consumível que pode ser feita repetidamente, concedendo 2.000 Dashes por compra.dash_upgrade_3d: uma compra de upgrade não consumível que só pode ser feita uma vez, desbloqueando o mascote Dash 3D.dash_subscription_doubler: uma assinatura com renovação automática que multiplica os cliques passivos enquanto está ativa.

Nas seções Compras no app (e Assinaturas) do seu app, crie os três produtos com estes IDs exatos:
- Consumível (
dash_consumable_2k):- Crie um produto Consumível com o nome de referência
dash consumable 2ke o ID do produtodash_consumable_2k.
- Configure a disponibilidade para que o produto esteja disponível no país ou na região do usuário do sandbox.

- Defina o preço como
\$1.99(ou o equivalente na moeda local).
- Adicione uma localização com o nome de exibição
Spring is in the aire a descrição2000 dashes fly out.
- Faça upload de uma captura de tela da avaliação. O conteúdo da imagem não importa para o teste de sandbox, mas o upload de uma captura de tela faz com que o produto mude para o estado Pronto para envio, que é necessário para que o app busque o produto no StoreKit.

- Crie um produto Consumível com o nome de referência
- Não consumível (
dash_upgrade_3d):- Crie um produto Não consumível com o nome de referência
dash upgrade 3de o ID do produtodash_upgrade_3d. - Defina o nome de exibição como
3D Dash, a descrição comoBrings your dash back to the futuree o preço como\$0.99. - Configure a disponibilidade e faça upload de uma captura de tela de revisão, assim como você fez para
dash_consumable_2k.
- Crie um produto Não consumível com o nome de referência
- Assinatura com renovação automática (
dash_subscription_doubler):- Em Assinaturas, crie um Grupo de assinaturas chamado
subscriptions(os usuários podem assinar apenas um produto do mesmo grupo por vez e fazer upgrade ou downgrade dentro do grupo).
- Adicione uma localização da App Store para o grupo de assinaturas.

- No grupo, crie uma assinatura com o nome de referência
dash subscription doublere o ID do produtodash_subscription_doubler.
- Defina a duração da assinatura como 1 semana, o nome de exibição como
Jet Engine, a descrição comoDoubles your clickse o preço como\$0.49. Configure a disponibilidade e faça upload de uma captura de tela de revisão para que o status mude para Pronto para envio.
- Em Assinaturas, crie um Grupo de assinaturas chamado
Agora, seus produtos vão aparecer no App Store Connect com o status Pronto para envio:


5. Configurar a Google Play Store
Para testar compras no app no Android, você precisa de uma conta de desenvolvedor do Google Play. Se você ainda não tiver uma, registre uma conta de desenvolvedor do Google Play.
Criar um novo app
Crie um novo app no Google Play Console:
- Abra o Google Play Console.
- Selecione Todos os apps > Criar app.
- Escolha um idioma padrão e insira o nome do app (você pode mudar isso depois).
- Selecione Jogo como o tipo de app e Sem custo financeiro como o modelo de preços.
- Preencha as declarações das Políticas do programa para desenvolvedores e das Leis de exportação dos EUA e selecione Criar app.
Depois de criar o app, conclua as tarefas iniciais de configuração no painel:

Assinar o aplicativo
Para testar o Google Play Faturamento, faça upload de pelo menos uma versão assinada appbundle para uma faixa de teste no Google Play Console.
Criar um keystore
Se você ainda não tiver um keystore de upload, gere um no terminal.
No macOS ou Linux:
keytool -genkey -v -keystore ~/key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias key
No Windows:
keytool -genkey -v -keystore c:\Users\USER_NAME\key.jks -storetype JKS -keyalg RSA -keysize 2048 -validity 10000 -alias key
Criar app/android/key.properties
Crie app/android/key.properties com uma referência ao seu 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>
Peça ao Antigravity para configurar a assinatura de lançamento no Gradle
Envie o seguinte comando no Antigravity para configurar a assinatura de versões em 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.
O Antigravity atualiza o app/android/app/build.gradle.kts para carregar o key.properties e assinar builds de lançamento:
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")
}
}
}
Fazer upload da primeira versão
Crie um pacote de app de lançamento assinado em app/:
cd app
flutter build appbundle
O pacote de lançamento é gravado em app/build/app/outputs/bundle/release/app-release.aab.
No Google Play Console, acesse Testar e lançar > Teste > Teste fechado, crie uma versão de teste fechado, faça upload de app-release.aab e clique em Salvar > Revisar versão > Iniciar lançamento para teste fechado.
Configurar usuários de teste
Para testar compras no app no Android, adicione as Contas do Google dos testadores em dois lugares no Google Play Console:
- Testadores da faixa de teste: acesse Testar e lançar > Teste > Teste interno (ou Teste fechado), abra a guia Testadores, clique em Criar lista de e-mails, adicione os endereços de e-mail dos testadores, selecione a lista e clique em Salvar mudanças.

- Testadores de licença: volte para a visualização Todos os apps, selecione Configurações > Teste de licença, adicione os mesmos endereços de e-mail dos testadores, defina Resposta da licença como
RESPOND_NORMALLYe clique em Salvar alterações.
Configurar as compras no app
Configure os mesmos três IDs de produto no Google Play Console:
dash_consumable_2k: compra de consumível que concede 2.000 Dashes.dash_upgrade_3d: upgrade único não consumível do 3D Dash.dash_subscription_doubler: assinatura de renovação automática do multiplicador de cliques.
Primeiro, crie os produtos únicos (dash_consumable_2k e dash_upgrade_3d):
- Selecione seu app no Google Play Console e acesse Monetizar com o Google Play > Produtos > Produtos no app.
- Clique em Criar produto.

- Insira o ID do produto (
dash_consumable_2k), o nome, a descrição e o preço exatos e clique em Salvar e Ativar. - Repita o processo para
dash_upgrade_3d.
Em seguida, crie a assinatura (dash_subscription_doubler):
- Acesse Monetizar com o Google Play > Produtos > Assinaturas e clique em Criar assinatura.

- Insira o ID do produto (
dash_subscription_doubler), adicione um plano básico com um período de faturamento semanal e um preço, depois clique em Salvar e Ativar.
6. Configurar o Firebase
Usar um serviço de back-end com o Cloud Firestore para verificar e rastrear compras oferece várias vantagens de segurança ao app:
- Você verifica as transações diretamente com os servidores do Google Play e da Apple.
- É possível reagir a eventos de faturamento do lado do servidor, como renovações ou cancelamentos.
- Você armazena uma única fonte de verdade no Cloud Firestore associada a cada usuário autenticado.
- Os usuários não podem desbloquear benefícios premium adulterando o relógio do dispositivo.
Criar um projeto do Firebase
- Abra o console do Firebase e crie um projeto do Firebase (por exemplo, Dash Clicker).
- Acesse Build > Autenticação, clique em Começar, abra a guia Método de login e ative o provedor de login do Google.

- Acesse Build > Banco de dados do Firestore e crie um banco de dados.

- Abra a guia Regras no Cloud Firestore e publique as regras de segurança abaixo para que os usuários autenticados possam ler apenas os próprios documentos de compra:
rules_version = '2';
service cloud.firestore {
match /databases/{database}/documents {
match /purchases/{purchaseId} {
allow read: if request.auth != null && request.auth.uid == resource.data.userId
}
}
}
Configurar o Firebase para Flutter
Siga o guia de configuração do FlutterFire para instalar a CLI do FlutterFire e execute flutterfire configure em app/:
cd app
flutterfire configure
- Selecione o projeto do Firebase que você criou.
- Ative android e ios.
- Confirme yes quando for solicitado que você substitua
lib/firebase_options.dart.
Configurar o Firebase para Android: certificado SHA-1 de depuração
O Login do Google no Android exige o registro da impressão digital SHA-1 do keystore de depuração no console do Firebase:
- No console do Firebase, abra Visão geral do projeto > Configurações do projeto > Geral, role para baixo até Seus apps e selecione seu app Android:

- Gere um relatório de assinatura de
app/android/:cd app/android ./gradlew :app:signingReport - Localize a impressão digital
SHA1emVariant: debugeConfig: debug, adicione-a ao seu app Android no console do Firebase e execute novamenteflutterfire configureemapp/para quegoogle-services.jsonelib/firebase_options.dartincluam a configuração atualizada do cliente OAuth.
Configurar o Firebase para iOS: configurar esquemas de URL
Para oferecer suporte ao Login do Google no iOS, o app/ios/Runner/Info.plist precisa incluir o REVERSED_CLIENT_ID de app/ios/Runner/GoogleService-Info.plist em CFBundleURLTypes (consulte a documentação de integração do google_sign_in com o iOS).
Você pode pedir para o Antigravity copiar REVERSED_CLIENT_ID e CLIENT_ID de app/ios/Runner/GoogleService-Info.plist para 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.
Em app/ios/Runner/Info.plist, a entrada CFBundleURLTypes tem esta aparência:
<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. Detectar atualizações de compras
Nesta etapa, você vai preparar o app do Flutter para detectar atualizações de compra na loja assim que o app for iniciado e manter a árvore de widgets testável introduzindo um wrapper IAPConnection substituível.
Solicitar que o Antigravity detecte atualizações de compra
Envie o seguinte comando no 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`.
Noções básicas sobre o código gerado
Inicialização de provedor antecipada e IAPConnection em app/lib/main.dart
Por padrão, o Provider cria o valor de forma lenta quando um widget o lê pela primeira vez. Como as transações na loja física pendentes podem chegar em purchaseStream imediatamente na inicialização, ChangeNotifierProvider define lazy: false. Além disso, o IAPConnection fornece uma costura estática para que os testes de widget possam injetar uma implementação InAppPurchase falsa:
class IAPConnection {
static InAppPurchase? _instance;
static set instance(InAppPurchase value) {
_instance = value;
}
static InAppPurchase get instance {
_instance ??= InAppPurchase.instance;
return _instance!;
}
}
ChangeNotifierProvider<DashPurchases>(
create: (context) => DashPurchases(context.read<DashCounter>()),
lazy: false,
),
Assinando purchaseStream em app/lib/logic/dash_purchases.dart
Em DashPurchases, o construtor se inscreve em iapConnection.purchaseStream, e dispose() cancela _subscription:
final iapConnection = IAPConnection.instance;
DashPurchases(this.counter) {
final purchaseUpdated = iapConnection.purchaseStream;
_subscription = purchaseUpdated.listen(
_onPurchaseUpdate,
onDone: _updateStreamOnDone,
onError: _updateStreamOnError,
);
}
@override
void dispose() {
_subscription.cancel();
super.dispose();
}
Executar e testar o app
Execute o pacote de testes de widget em app/ para verificar se TestIAPConnection simula a conexão da loja de forma limpa:
cd app
flutter test
8. Fazer compras
Nesta etapa, você vai substituir os produtos simulados fixados no código por produtos reais da loja buscados usando queryProductDetails, iniciar compras quando o usuário tocar em um produto e concluir transações quando as atualizações chegarem em purchaseStream.
Peça para o Antigravity carregar e fazer compras
Envie o seguinte comando no 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.
Noções básicas sobre o código gerado
Como unir ProductDetails em app/lib/model/purchasable_product.dart
PurchasableProduct envolve o ProductDetails retornado pelo repositório enquanto rastreia a ProductStatus da interface local (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;
}
Consultando produtos em app/lib/logic/dash_purchases.dart
loadPurchases() primeiro verifica se a loja em questão pode ser acessada com iapConnection.isAvailable() e, em seguida, consulta os três IDs de produto definidos em app/lib/constants.dart:
Future<void> loadPurchases() async {
final available = await iapConnection.isAvailable();
if (!available) {
storeState = StoreState.notAvailable;
notifyListeners();
return;
}
const ids = <String>{
storeKeyConsumable,
storeKeySubscription,
storeKeyUpgrade,
};
final response = await iapConnection.queryProductDetails(ids);
products = response.productDetails
.map((e) => PurchasableProduct(e))
.toList();
storeState = StoreState.available;
notifyListeners();
}
Iniciar e concluir compras
Quando um usuário toca em um produto em PurchasePage, buy() cria um PurchaseParam e envia consumíveis para buyConsumable e upgrades únicos ou assinaturas para 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',
);
}
}
Quando a loja emite objetos PurchaseDetails atualizados em purchaseStream, _handlePurchase concede o prêmio correspondente e confirma a conclusão chamando 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);
}
}
Executar e testar o app
Execute flutter test em app/ e inicie o app no dispositivo de teste configurado. Quando os produtos da sua loja estão ativos, eles aparecem na guia Comprar prontos para serem adquiridos:

9. configurar o back-end
Antes de verificar e acompanhar as compras em um servidor, você vai estruturar o serviço de back-end do Dart em dart-backend/ com app/ e configurar as credenciais do Firebase, do Google Play e da App Store.
Pedir ao Antigravity para criar o back-end do Dart
No painel de conversa do agente do Antigravity, envie o seguinte comando para criar o projeto 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)`.
Noções básicas sobre o código gerado
dart-backend/bin/server.dartinicializa umshelf_routerRoutere disponibiliza solicitações HTTP na porta8080usandoserveHandleremdart-backend/lib/helpers.dart.dart-backend/lib/products.dartmapeia cada ID do produto (dash_consumable_2k,dash_upgrade_3dedash_subscription_doubler) para oProductType(nonSubscriptionousubscription).dart-backend/lib/iap_repository.dartencapsula a leitura e a gravação de documentosNonSubscriptionPurchaseeSubscriptionPurchasena coleçãopurchasesdo Cloud Firestore usandoFirestoreApi.
Para testar se o servidor é iniciado localmente, execute:
cd dart-backend
dart run ./bin/server.dart
Configurar o acesso ao Firebase
Para permitir que o dart-backend/ grave compras verificadas no Cloud Firestore, gere uma chave de conta de serviço:
- No console do Firebase, abra Configurações do projeto > Contas de serviço e clique em Gerar nova chave privada.

- Salve o arquivo JSON salvo como
dart-backend/assets/service-account-firebase.json.
Configurar o acesso ao Google Play
Para permitir que o dart-backend/ verifique as compras do Android com a API Google Play Android Developer:
- Abra a página da API Google Play Android Developer no console do Google Cloud e ative a API.

- Acesse a página Contas de serviço do Google Cloud e clique em + Criar conta de serviço.

- Insira um nome para a conta de serviço e clique em Criar e continuar.

- Conceda o papel Assinante do Pub/Sub e clique em Concluído.

- Abra o menu de ações da conta de serviço recém-criada e selecione Gerenciar chaves.

- Selecione Adicionar chave > Criar nova chave, escolha JSON e faça o download da chave:


- Salve o arquivo baixado como
dart-backend/assets/service-account-google-play.json. - Abra Usuários e permissões no Google Play Console, clique em Convidar novos usuários e insira o endereço de e-mail da conta de serviço:


- Conceda as permissões Ver dados financeiros e Gerenciar pedidos e assinaturas para o app e clique em Convidar usuário.

Configurar o acesso à App Store da Apple
Para verificar os recibos da App Store no back-end, gere um segredo compartilhado específico do app:
- Abra o App Store Connect, selecione Apps e escolha seu app.
- Na barra lateral, acesse Geral > Informações do app.
- Em App-Specific Shared Secret, clique em Manage, gere um novo segredo compartilhado e copie-o:


Atualizar dart-backend/lib/constants.dart
Verifique se as seguintes constantes estão definidas em dart-backend/lib/constants.dart:
androidPackageId: oapplicationIddo Android (comocom.example.dashclicker).appStoreSharedSecret: sua chave secreta compartilhada do App Store Connect.bundleId: o identificador do pacote do iOS (comocom.example.dashclicker).
10. Verificar compras
Quando um usuário conclui uma compra no iOS ou no Android, a loja emite um token de verificação (PurchaseDetails.verificationData.serverVerificationData). Em vez de confiar diretamente no dispositivo cliente, o app Flutter envia esse token para dart-backend/, que o verifica com o Google Play ou a App Store e registra a compra no Cloud Firestore.

Peça para o Antigravity verificar as compras no cliente e no back-end
Envie o comando a seguir no Antigravity para conectar o app Flutter e o fluxo de verificação de back-end do 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.
Noções básicas sobre o código gerado
Restringir compras com autenticação e chamar /verifypurchase
Em app/lib/pages/purchase_page.dart, PurchasePage verifica FirebaseNotifier e mostra LoginPage até que o usuário faça login:
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();
}
Em app/lib/logic/dash_purchases.dart, _verifyPurchase publica a origem da loja (google_play ou app_store), productID, serverVerificationData e o userId conectado ao back-end do Dart antes que _handlePurchase conceda a recompensa no app:
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;
}
}
Roteamento e correspondência de padrões do Dart 3 em dart-backend/bin/server.dart
No servidor, POST /verifypurchase decodifica o corpo da solicitação JSON com getPurchaseData usando um padrão de mapa do Dart 3 e um tipo de retorno de registro. Em seguida, ele delega a verificação ao gerenciador de loja correspondente:
router.post('/verifypurchase', (Request request) async {
final dynamic payload = json.decode(await request.readAsString());
final (:userId, :source, :productData, :token) = getPurchaseData(payload);
final result = await purchaseHandlers[source]!.verifyPurchase(
userId: userId,
productData: productData,
token: token,
);
if (result) {
return Response.ok('all good!');
} else {
return Response.internalServerError();
}
});
({String userId, String source, ProductData productData, String token})
getPurchaseData(dynamic payload) {
if (payload case {
'userId': String userId,
'source': String source,
'productId': String productId,
'verificationData': String token,
}) {
return (
userId: userId,
source: source,
productData: productDataMap[productId]!,
token: token,
);
} else {
throw const FormatException('Unexpected JSON');
}
}
Verificação de recibos do Google Play e da App Store
- Em
dart-backend/lib/google_play_purchase_handler.dart,GooglePlayPurchaseHandlerconsultaandroidPublisher.purchases.products.getpara produtos únicos eandroidPublisher.purchases.subscriptions.getpara assinaturas, remove os sufixos de renovação..#dos códigos do pedido de assinatura usandoextractOrderIde grava oNonSubscriptionPurchaseouSubscriptionPurchaseresultante no Cloud Firestore usandoiapRepository. - Em
dart-backend/lib/app_store_purchase_handler.dart,AppStorePurchaseHandlerchama_iTunesAPI.verifyReceiptusando o pacoteapp_store_server_sdke mantém cada recibo verificado emresponse.latestReceiptInfono Cloud Firestore.
Executar e testar o back-end
Inicie o servidor de back-end em dart-backend/:
cd dart-backend
dart run bin/server.dart
11. Acompanhar compras
As assinaturas podem ser renovadas, expirar ou ser canceladas fora do app. Nesta etapa, você vai configurar o back-end para consultar as atualizações de faturamento da loja no Google Cloud Pub/Sub e na API App Store Server, além de atualizar o cliente do Flutter para sincronizar de forma reativa os direitos ativos do usuário no Cloud Firestore usando IAPRepo.
Configurar as chaves de API do Cloud Pub/Sub e da API App Store Server
Configuração do Cloud Pub/Sub do Google Play
- Defina
googleCloudProjectIdemdart-backend/lib/constants.dartcomo o ID do projeto do Google Cloud e do Firebase. - Abra a página de tópicos do Cloud Pub/Sub no console do Google Cloud, verifique se o projeto está selecionado e clique em + Criar tópico.

- Defina o ID do tópico como
play_billing(correspondente agooglePlayPubsubBillingTopicemdart-backend/lib/constants.dart, que cria automaticamente uma assinatura padrãoplay_billing-sub) e clique em Criar.
- Abra o menu de três pontos no tópico
play_billinge selecione Ver permissões.
- Clique em Adicionar principal, insira
google-play-developer-notifications@system.gserviceaccount.com, atribua o papel Publicador do Pub/Sub e clique em Salvar.
- Copie o nome completo do tópico, abra o app no Google Play Console, acesse Monetizar com o Google Play > Configuração de monetização, cole o nome do tópico e clique em Salvar alterações.

Configuração da chave de API do App Store Server
- Faça login no App Store Connect e selecione Users and Access.
- Acesse Integrations > Keys > Compra no app e clique no botão + para gerar uma nova chave (por exemplo,
Codelab key). - Faça o download do arquivo de chave
.p8e salve-o comodart-backend/assets/SubscriptionKey.p8. - Copie o ID da chave e o ID do emissor para
appStoreKeyIdeappStoreIssuerIdemdart-backend/lib/constants.dart.

Pedir para o Antigravity consultar eventos da loja e sincronizar o estado do cliente
Envie o seguinte comando no 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.
Noções básicas sobre o código gerado
Sondagem do Pub/Sub do Google Play e da API App Store Server no back-end
Em dart-backend/lib/google_play_purchase_handler.dart, _pullMessageFromPubSub pesquisa a assinatura projects/$googleCloudProjectId/subscriptions/$googlePlayPubsubBillingTopic-sub a cada 10 segundos, decodifica cada payload de notificação em base64, executa novamente handleSubscription ou handleNonSubscription para atualizar o Firestore e confirma a mensagem usando _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);
}
}
}
Da mesma forma, em dart-backend/lib/app_store_purchase_handler.dart, _pullStatus consulta appStoreServerAPI.getAllSubscriptionStatuses(purchase.orderId) a cada 10 segundos e atualiza expiryDate e SubscriptionStatus (active ou expired) de cada assinatura no Cloud Firestore.
Sincronização de compras do Firestore no dispositivo
No app/lib/repo/iap_repo.dart, o IAPRepo detecta os documentos purchases do usuário autenticado no Cloud Firestore em tempo real e calcula hasActiveSubscription e 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();
});
Sempre que IAPRepo notifica os listeners, DashPurchases.purchasesUpdate() em app/lib/logic/dash_purchases.dart ativa ou desativa o multiplicador de cliques de 10x, alterna _beautifiedDashUpgrade e atualiza os status dos produtos mostrados em 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();
}
}
Executar e testar o app e o back-end
Execute os testes de unidade e de widget nos dois projetos para verificar se tudo é analisado e aprovado sem problemas:
cd dart-backend
dart test
cd ../app
flutter test
12. Parabéns
Parabéns! Você colaborou com o Google Antigravity para criar uma integração de compra no app de pilha completa no Flutter com um back-end de verificação do Dart.
O que você criou
- Configurou produtos consumíveis (
dash_consumable_2k), não consumíveis (dash_upgrade_3d) e de assinatura com renovação automática (dash_subscription_doubler) no App Store Connect e no Google Play Console. - Conectou o app Dash Clicker do Flutter (
app/) ao plug-inin_app_purchase, consultando detalhes do produto e detectandopurchaseStream. - Criou um back-end Dart
shelf(dart-backend/) que verifica tokens de compra com a API Google Play Android Developer e a App Store, pesquisa atualizações de faturamento usando o Cloud Pub/Sub e a API App Store Server e mantém o estado da compra no Cloud Firestore. - Sincronização em tempo real dos direitos de compra verificados com o cliente do Flutter usando
IAPRepo.
Próximas etapas
- Adicione o middleware de verificação de token de ID do Firebase Auth a
POST /verifypurchaseemdart-backend/bin/server.dart. - Implante o
dart-backend/no Cloud Run e configure webhooks de push para o Google Cloud Pub/Sub e as notificações do servidor da App Store.






