Como adicionar compras ao seu app do Flutter

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:

  1. Consumível (dash_consumable_2k): uma compra repetível que concede imediatamente ao jogador 2.000 Dashes e pode ser comprada várias vezes.
  2. 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.
  3. Assinatura (dash_subscription_doubler): uma assinatura com renovação automática que multiplica os cliques gerados passivamente enquanto ela permanece ativa.

Tela inicial do Dash Clicker mostrando o mascote clássico do Dash e o contador de toques

Tela de compra do Dash Clicker listando os produtos no app disponíveis e as compras anteriores

Tela inicial do Dash Clicker após a compra do upgrade do Dash 3D

O que você vai criar

  • Um app para dispositivos móveis do Flutter (app/) estilizado com material_ui e cupertino_ui que 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:

  1. 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 o applicationId do Android.
  2. Instalar o plug-in: peça para o Antigravity adicionar in_app_purchase e in_app_purchase_platform_interface a app/.
  3. 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.
  4. 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.
  5. Configurar o Firebase: ative o Login do Google e o Cloud Firestore no console do Firebase, execute flutterfire configure e configure as impressões digitais SHA-1 do Android e os esquemas de URL do iOS.
  6. Detectar atualizações de compra: peça para o Antigravity adicionar um wrapper IAPConnection testável, se inscrever em purchaseStream e testar o app com TestIAPConnection.
  7. Fazer compras: peça para o Antigravity encapsular ProductDetails em PurchasableProduct, consultar produtos da loja, acionar buyConsumable e buyNonConsumable e concluir compras pendentes.
  8. Configurar o back-end: peça para o Antigravity criar o servidor dart-backend/ com IapRepository e configurar as credenciais da conta de serviço.
  9. Verificar compras: peça para o Antigravity exigir o login do Firebase em PurchasePage, postar tokens de compra em /verifypurchase e implementar GooglePlayPurchaseHandler e AppStorePurchaseHandler.
  10. 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:

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

  1. 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 ou C:\src\.
  2. 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.dart registra cinco ChangeNotifierProviders (FirebaseNotifier, DashCounter, DashUpgrades, IAPRepo e DashPurchases) dentro de MyHomePage e alterna entre HomePage e PurchasePage.
  • app/lib/constants.dart define 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:

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

Como configurar a equipe e o identificador do pacote em "Signing & Capabilities" do Xcode

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:

Como definir applicationId em android/app/build.gradle.kts

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_purchase fornece a API multiplataforma InAppPurchase, que usa o StoreKit no iOS e o Google Play Faturamento no Android.
  • in_app_purchase_platform_interface expõe InAppPurchasePlatformAddition, que permite implementar um cliente InAppPurchase simulado em app/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.

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

Painel inicial do App Store Connect destacando "Agreements, Tax, and Banking" (Contratos, tributos e serviços bancários)

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.

Lista de contratos do App Store Connect mostrando apps sem custo financeiro ativos e apps pagos novos

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.

Lista de contratos do App Store Connect mostrando os apps sem custo financeiro e apps pagos ativos

Registrar um ID de app

Crie um novo ID do app no portal do desenvolvedor da Apple:

  1. Acesse Apple Developer Identifiers e clique no ícone + ao lado do cabeçalho Identifiers.Lista de identificadores do portal do desenvolvedor da Apple com o botão de adição destacado
  2. Selecione IDs de apps e clique em Continuar.Tela "Register a new identifier" com a opção "App IDs" selecionada
  3. Selecione App como o tipo e clique em Continuar.Tela de seleção de tipo com a opção "App" selecionada
  4. 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.Formulário de registro de um ID do app mostrando a descrição e o ID do pacote explícito

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:

Menu "Apps" do App Store Connect mostrando a opção "Novo app"

Caixa de diálogo "Novo app" no App Store Connect mostrando os campos de plataforma, nome, idioma, ID do pacote e SKU

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.

Lista de testadores do Sandbox do App Store Connect

No iPhone ou iPad de teste, faça login com sua conta de sandbox em Ajustes > Desenvolvedor > Conta da Apple de sandbox.

Tela de configurações do iOS mostrando a seção "Sandbox Apple Account"

Tela de configurações do iOS mostrando uma Conta Apple de sandbox conectada

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.

Barra lateral do App Store Connect destacando as compras no app e as assinaturas

Nas seções Compras no app (e Assinaturas) do seu app, crie os três produtos com estes IDs exatos:

  1. Consumível (dash_consumable_2k):
    • Crie um produto Consumível com o nome de referência dash consumable 2k e o ID do produto dash_consumable_2k.Criar um modal de compra no app configurado para dash_consumable_2k
    • Configure a disponibilidade para que o produto esteja disponível no país ou na região do usuário do sandbox.Configuração de disponibilidade para a compra no app
    • Defina o preço como \$1.99 (ou o equivalente na moeda local).Configuração da programação de preços definida como US $1,99
    • Adicione uma localização com o nome de exibição Spring is in the air e a descrição 2000 dashes fly out.Localização da app store mostrando o nome de exibição e a descrição
    • 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.Seção "Revisar informações" com uma imagem de prévia do produto enviado
  2. Não consumível (dash_upgrade_3d):
    • Crie um produto Não consumível com o nome de referência dash upgrade 3d e o ID do produto dash_upgrade_3d.
    • Defina o nome de exibição como 3D Dash, a descrição como Brings your dash back to the future e 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.Configuração de produto não consumível para dash_upgrade_3d
  3. 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).Caixa de diálogo "Criar grupo de assinaturas"
    • Adicione uma localização da App Store para o grupo de assinaturas.Caixa de diálogo de localização da app store para o grupo de assinaturas
    • No grupo, crie uma assinatura com o nome de referência dash subscription doubler e o ID do produto dash_subscription_doubler.Caixa de diálogo "Criar assinatura" para dash_subscription_doubler
    • Defina a duração da assinatura como 1 semana, o nome de exibição como Jet Engine, a descrição como Doubles your clicks e 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.Configurações de duração, preço e localização da assinatura

Agora, seus produtos vão aparecer no App Store Connect com o status Pronto para envio:

Lista de compras no app mostrando dash_consumable_2k e dash_upgrade_3d como "Pronto para envio"

Lista de assinaturas mostrando dash_subscription_doubler como "Pronto para enviar"

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:

  1. Abra o Google Play Console.
  2. Selecione Todos os apps > Criar app.
  3. Escolha um idioma padrão e insira o nome do app (você pode mudar isso depois).
  4. Selecione Jogo como o tipo de app e Sem custo financeiro como o modelo de preços.
  5. 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:

Painel do Google Play Console mostrando a lista de verificação "Configurar seu app"

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:

  1. 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.Guia &quot;Testadores&quot; do teste interno do Google Play Console
  2. 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_NORMALLY e clique em Salvar alterações.Configurações de teste de licença do Google Play Console

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

  1. Selecione seu app no Google Play Console e acesse Monetizar com o Google Play > Produtos > Produtos no app.
  2. Clique em Criar produto.Página &quot;Produtos no app&quot; do Google Play Console com o botão &quot;Criar produto&quot;
  3. Insira o ID do produto (dash_consumable_2k), o nome, a descrição e o preço exatos e clique em Salvar e Ativar.
  4. Repita o processo para dash_upgrade_3d.

Em seguida, crie a assinatura (dash_subscription_doubler):

  1. Acesse Monetizar com o Google Play > Produtos > Assinaturas e clique em Criar assinatura.Página &quot;Assinaturas&quot; do Google Play Console com o botão &quot;Criar assinatura&quot;
  2. 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

  1. Abra o console do Firebase e crie um projeto do Firebase (por exemplo, Dash Clicker).
  2. Acesse Build > Autenticação, clique em Começar, abra a guia Método de login e ative o provedor de login do Google.Guia &quot;Método de login&quot; do Firebase Authentication mostrando o Google ativado
  3. Acesse Build > Banco de dados do Firestore e crie um banco de dados.Banner de criação do Cloud Firestore no console do Firebase
  4. 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
  1. Selecione o projeto do Firebase que você criou.
  2. Ative android e ios.
  3. 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:

  1. 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:Configurações do projeto do Firebase mostrando a configuração do app Android e o botão &quot;Adicionar impressão digital&quot;
  2. Gere um relatório de assinatura de app/android/:
    cd app/android
    ./gradlew :app:signingReport
    
  3. Localize a impressão digital SHA1 em Variant: debug e Config: debug, adicione-a ao seu app Android no console do Firebase e execute novamente flutterfire configure em app/ para que google-services.json e lib/firebase_options.dart incluam 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:

Guia &quot;Compra&quot; do Dash Clicker mostrando os três produtos carregados da loja

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.dart inicializa um shelf_router Router e disponibiliza solicitações HTTP na porta 8080 usando serveHandler em dart-backend/lib/helpers.dart.
  • dart-backend/lib/products.dart mapeia cada ID do produto (dash_consumable_2k, dash_upgrade_3d e dash_subscription_doubler) para o ProductType (nonSubscription ou subscription).
  • dart-backend/lib/iap_repository.dart encapsula a leitura e a gravação de documentos NonSubscriptionPurchase e SubscriptionPurchase na coleção purchases do Cloud Firestore usando FirestoreApi.

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:

  1. No console do Firebase, abra Configurações do projeto > Contas de serviço e clique em Gerar nova chave privada.Guia &quot;Contas de serviço&quot; das configurações do projeto do Firebase mostrando &quot;Gerar nova chave privada&quot;
  2. 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:

  1. Abra a página da API Google Play Android Developer no console do Google Cloud e ative a API.Página do console do Google Cloud para a API Google Play Android Developer
  2. Acesse a página Contas de serviço do Google Cloud e clique em + Criar conta de serviço.Página &quot;Contas de serviço&quot; do console do Google Cloud mostrando &quot;Criar conta de serviço&quot;
  3. Insira um nome para a conta de serviço e clique em Criar e continuar.Etapa de detalhes da conta de serviço
  4. Conceda o papel Assinante do Pub/Sub e clique em Concluído.Etapa &quot;Conceder a essa conta de serviço acesso ao projeto&quot; mostrando o papel de assinante do Pub/Sub
  5. Abra o menu de ações da conta de serviço recém-criada e selecione Gerenciar chaves.Menu de ações da conta de serviço destacando &quot;Gerenciar chaves&quot;
  6. Selecione Adicionar chave > Criar nova chave, escolha JSON e faça o download da chave:Menu &quot;Adicionar chave&quot; mostrando &quot;Criar nova chave&quot;Caixa de diálogo &quot;Criar chave privada&quot; com JSON selecionado
  7. Salve o arquivo baixado como dart-backend/assets/service-account-google-play.json.
  8. 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:Página &quot;Usuários e permissões&quot; do Google Play ConsoleTabela de contas de serviço do Google Cloud mostrando o endereço de e-mail da conta de serviço
  9. Conceda as permissões Ver dados financeiros e Gerenciar pedidos e assinaturas para o app e clique em Convidar usuário.Guia &quot;Permissões do app&quot; mostrando as opções &quot;Ver dados financeiros&quot; e &quot;Gerenciar pedidos e assinaturas&quot; marcadas

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:

  1. Abra o App Store Connect, selecione Apps e escolha seu app.
  2. Na barra lateral, acesse Geral > Informações do app.
  3. Em App-Specific Shared Secret, clique em Manage, gere um novo segredo compartilhado e copie-o:Seção &quot;Segredo compartilhado específico do app&quot; do App Store ConnectModal de chave secreta compartilhada específica do app mostrando a chave gerada

Atualizar dart-backend/lib/constants.dart

Verifique se as seguintes constantes estão definidas em dart-backend/lib/constants.dart:

  • androidPackageId: o applicationId do Android (como com.example.dashclicker).
  • appStoreSharedSecret: sua chave secreta compartilhada do App Store Connect.
  • bundleId: o identificador do pacote do iOS (como com.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.

Hierarquia de classes PurchaseHandler implementada por GooglePlayPurchaseHandler e AppStorePurchaseHandler

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, GooglePlayPurchaseHandler consulta androidPublisher.purchases.products.get para produtos únicos e androidPublisher.purchases.subscriptions.get para assinaturas, remove os sufixos de renovação ..# dos códigos do pedido de assinatura usando extractOrderId e grava o NonSubscriptionPurchase ou SubscriptionPurchase resultante no Cloud Firestore usando iapRepository.
  • Em dart-backend/lib/app_store_purchase_handler.dart, AppStorePurchaseHandler chama _iTunesAPI.verifyReceipt usando o pacote app_store_server_sdk e mantém cada recibo verificado em response.latestReceiptInfo no 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

  1. Defina googleCloudProjectId em dart-backend/lib/constants.dart como o ID do projeto do Google Cloud e do Firebase.
  2. 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.Página de tópicos do Google Cloud Pub/Sub mostrando o botão &quot;Criar tópico&quot;
  3. Defina o ID do tópico como play_billing (correspondente a googlePlayPubsubBillingTopic em dart-backend/lib/constants.dart, que cria automaticamente uma assinatura padrão play_billing-sub) e clique em Criar.Caixa de diálogo &quot;Criar um tópico&quot; com o ID do tópico play_billing
  4. Abra o menu de três pontos no tópico play_billing e selecione Ver permissões.Menu de tópicos do Pub/Sub destacando as permissões de leitura
  5. Clique em Adicionar principal, insira google-play-developer-notifications@system.gserviceaccount.com, atribua o papel Publicador do Pub/Sub e clique em Salvar.Painel &quot;Adicionar participantes&quot; concedendo o papel de Publicador do Pub/Sub a google-play-developer-notifications
  6. 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 de monetização do Google Play Console mostrando o nome do tópico &quot;Notificações do desenvolvedor em tempo real&quot;

Configuração da chave de API do App Store Server

  1. Faça login no App Store Connect e selecione Users and Access.
  2. Acesse Integrations > Keys > Compra no app e clique no botão + para gerar uma nova chave (por exemplo, Codelab key).
  3. Faça o download do arquivo de chave .p8 e salve-o como dart-backend/assets/SubscriptionKey.p8.
  4. Copie o ID da chave e o ID do emissor para appStoreKeyId e appStoreIssuerId em dart-backend/lib/constants.dart.

Lista de chaves de compra no app do App Store Connect mostrando o ID do emissor e o ID da chave

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-in in_app_purchase, consultando detalhes do produto e detectando purchaseStream.
  • 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 /verifypurchase em dart-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.

Saiba mais