向 Flutter 应用添加应用内购商品

git clone https://github.com/flutter/codelabs.git flutter-codelabs 

gh repo clone flutter/codelabs flutter-codelabs 

cd flutter-codelabs/in_app_purchases/step_00 

$ cd app $ flutter pub add in_app_purchase dev:in_app_purchase_platform_interface 

dependencies:   flutter:     sdk: flutter   cloud_firestore: ^5.6.3   cupertino_icons: ^1.0.8   firebase_auth: ^5.4.2   firebase_core: ^3.11.0   google_sign_in: ^6.2.2   http: ^1.3.0   intl: ^0.20.2   provider: ^6.1.2   in_app_purchase: ^3.2.1  dev_dependencies:   flutter_test:     sdk: flutter   flutter_lints: ^5.0.0   in_app_purchase_platform_interface: ^1.4.0 

keytool -genkey -v -keystore ~/key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias key 

keytool -genkey -v -keystore c:\Users\USER_NAME\key.jks -storetype JKS -keyalg RSA -keysize 2048 -validity 10000 -alias key 

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> 

import java.util.Properties import java.io.FileInputStream  plugins {     // omitted }  val keystoreProperties = Properties() val keystorePropertiesFile = rootProject.file("key.properties") if (keystorePropertiesFile.exists()) {     keystoreProperties.load(FileInputStream(keystorePropertiesFile)) }  android {     // omitted } 

   buildTypes {         release {             signingConfig = signingConfigs.getByName("release")         }     } 

   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")         }     } 

flutter build appbundle 

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

$ flutterfire configure  i Found 5 Firebase projects.                                                                                                   ? Select a Firebase project to configure your Flutter application with ›                                                       ❯ in-app-purchases-1234 (in-app-purchases-1234)                                                                            other-flutter-codelab-1 (other-flutter-codelab-1)                                                                              other-flutter-codelab-2 (other-flutter-codelab-2)                                                                         other-flutter-codelab-3 (other-flutter-codelab-3)                                                                              other-flutter-codelab-4 (other-flutter-codelab-4)                                                                                                                                                                  <create a new project>   

? Which platforms should your configuration support (use arrow keys & space to select)? ›                                      ✔ android                                                                                                                      ✔ ios                                                                                                                            macos                                                                                                                          web                                                                                                                           

? Generated FirebaseOptions file lib/firebase_options.dart already exists, do you want to override it? (y/n) › yes                                                                                                                          

cd android ./gradlew :app:signingReport 

> Task :app:signingReport Variant: debug Config: debug Store: /<USER_HOME_FOLDER>/.android/debug.keystore Alias: AndroidDebugKey MD5: XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX SHA1: XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX SHA-256: XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX:XX Valid until: Tuesday, January 19, 2038 

$ flutterfire configure ? You have an existing `firebase.json` file and possibly already configured your project for Firebase. Would you prefer to reuse the valus in your existing `firebase.json` file to configure your project? (y/n) › yes ✔ You have an existing `firebase.json` file and possibly already configured your project for Firebase. Would you prefer to reuse the values in your existing `firebase.json` file to configure your project? · yes 

<key>CFBundleURLTypes</key> <array>     <dict>         <key>CFBundleTypeRole</key>         <string>Editor</string>         <key>CFBundleURLSchemes</key>         <array>             <!-- TODO Replace this value: -->             <!-- Copied from GoogleService-Info.plist key REVERSED_CLIENT_ID -->             <string>com.googleusercontent.apps.REDACTED</string>         </array>     </dict> </array> 

ChangeNotifierProvider<DashPurchases>(   create: (context) => DashPurchases(     context.read<DashCounter>(),   ),   lazy: false,                                             // Add this line ), 

// Gives the option to override in tests. class IAPConnection {   static InAppPurchase? _instance;   static set instance(InAppPurchase value) {     _instance = value;   }    static InAppPurchase get instance {     _instance ??= InAppPurchase.instance;     return _instance!;   } } 

import 'package:dashclicker/main.dart'; import 'package:flutter_test/flutter_test.dart'; import 'package:in_app_purchase/in_app_purchase.dart';     // Add this import import 'package:in_app_purchase_platform_interface/src/in_app_purchase_platform_addition.dart'; // And this import  void main() {   testWidgets('App starts', (tester) async {     IAPConnection.instance = TestIAPConnection();          // Add this line     await tester.pumpWidget(const MyApp());     expect(find.text('Tim Sneath'), findsOneWidget);   }); }  class TestIAPConnection implements InAppPurchase {         // Add from here   @override   Future<bool> buyConsumable(       {required PurchaseParam purchaseParam, bool autoConsume = true}) {     return Future.value(false);   }    @override   Future<bool> buyNonConsumable({required PurchaseParam purchaseParam}) {     return Future.value(false);   }    @override   Future<void> completePurchase(PurchaseDetails purchase) {     return Future.value();   }    @override   Future<bool> isAvailable() {     return Future.value(false);   }    @override   Future<ProductDetailsResponse> queryProductDetails(Set<String> identifiers) {     return Future.value(ProductDetailsResponse(       productDetails: [],       notFoundIDs: [],     ));   }    @override   T getPlatformAddition<T extends InAppPurchasePlatformAddition?>() {     // TODO: implement getPlatformAddition     throw UnimplementedError();   }    @override   Stream<List<PurchaseDetails>> get purchaseStream =>       Stream.value(<PurchaseDetails>[]);    @override   Future<void> restorePurchases({String? applicationUserName}) {     // TODO: implement restorePurchases     throw UnimplementedError();   }    @override   Future<String> countryCode() {     // TODO: implement countryCode     throw UnimplementedError();   } }                                                          // To here. 

import 'dart:async';  import 'package:flutter/foundation.dart'; import 'package:flutter/material.dart'; import 'package:in_app_purchase/in_app_purchase.dart';     // Add this import  import '../main.dart';                                     // And this import import '../model/purchasable_product.dart'; import '../model/store_state.dart'; import 'dash_counter.dart';  class DashPurchases extends ChangeNotifier {   DashCounter counter;   StoreState storeState = StoreState.available;   late StreamSubscription<List<PurchaseDetails>> _subscription;  // Add this line   List<PurchasableProduct> products = [     PurchasableProduct(       'Spring is in the air',       'Many dashes flying out from their nests',       '\$0.99',     ),     PurchasableProduct(       'Jet engine',       'Doubles you clicks per second for a day',       '\$1.99',     ),   ];    bool get beautifiedDash => false;    final iapConnection = IAPConnection.instance;            // And this line    DashPurchases(this.counter);    Future<void> buy(PurchasableProduct product) async {     product.status = ProductStatus.pending;     notifyListeners();     await Future<void>.delayed(const Duration(seconds: 5));     product.status = ProductStatus.purchased;     notifyListeners();     await Future<void>.delayed(const Duration(seconds: 5));     product.status = ProductStatus.purchasable;     notifyListeners();   } } 

class DashPurchases extends ChangeNotifier {   DashCounter counter;   StoreState storeState = StoreState.notAvailable;         // Modify this line   late StreamSubscription<List<PurchaseDetails>> _subscription;   List<PurchasableProduct> products = [     PurchasableProduct(       'Spring is in the air',       'Many dashes flying out from their nests',       '\$0.99',     ),     PurchasableProduct(       'Jet engine',       'Doubles you clicks per second for a day',       '\$1.99',     ),   ];    bool get beautifiedDash => false;    final iapConnection = IAPConnection.instance;    DashPurchases(this.counter) {                            // Add from here     final purchaseUpdated = iapConnection.purchaseStream;     _subscription = purchaseUpdated.listen(       _onPurchaseUpdate,       onDone: _updateStreamOnDone,       onError: _updateStreamOnError,     );   }    @override   void dispose() {     _subscription.cancel();     super.dispose();   }                                                        // To here.    Future<void> buy(PurchasableProduct product) async {     product.status = ProductStatus.pending;     notifyListeners();     await Future<void>.delayed(const Duration(seconds: 5));     product.status = ProductStatus.purchased;     notifyListeners();     await Future<void>.delayed(const Duration(seconds: 5));     product.status = ProductStatus.purchasable;     notifyListeners();   }                                                            // Add from here   void _onPurchaseUpdate(List<PurchaseDetails> purchaseDetailsList) {     // Handle purchases here   }    void _updateStreamOnDone() {     _subscription.cancel();   }    void _updateStreamOnError(dynamic error) {     //Handle error here   }                                                        // To here. } 

$ flutter test  00:01 +1: All tests passed!                                                                                    

import 'package:in_app_purchase/in_app_purchase.dart';  enum ProductStatus {   purchasable,   purchased,   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; } 

  Future<void> loadPurchases() async {     final available = await iapConnection.isAvailable();     if (!available) {       storeState = StoreState.notAvailable;       notifyListeners();       return;     }   } 

import '../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();   } 

  DashPurchases(this.counter) {     final purchaseUpdated = iapConnection.purchaseStream;     _subscription = purchaseUpdated.listen(       _onPurchaseUpdate,       onDone: _updateStreamOnDone,       onError: _updateStreamOnError,     );     loadPurchases();   } 

StoreState storeState = StoreState.loading; 

class _PurchaseList extends StatelessWidget {   @override   Widget build(BuildContext context) {     var purchases = context.watch<DashPurchases>();     var products = purchases.products;     return Column(       children: products           .map((product) => _PurchaseWidget(               product: product,               onPressed: () {                 purchases.buy(product);               }))           .toList(),     );   } } 

  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');     }   } 

  bool get beautifiedDash => _beautifiedDashUpgrade;   bool _beautifiedDashUpgrade = false; 

  Future<void> _onPurchaseUpdate(       List<PurchaseDetails> purchaseDetailsList) async {     for (var purchaseDetails in purchaseDetailsList) {       await _handlePurchase(purchaseDetails);     }     notifyListeners();   }    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);     }   } 

$ dart ./bin/server.dart  Serving at http://0.0.0.0:8080 

import '../logic/firebase_notifier.dart'; import '../model/firebase_state.dart'; import 'login_page.dart';  class PurchasePage extends StatelessWidget {     const PurchasePage({super.key});    @override   Widget build(BuildContext context) {     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();     }     // omitted 

  FirebaseNotifier firebaseNotifier;    DashPurchases(this.counter, this.firebaseNotifier) {     // omitted   } 

        ChangeNotifierProvider<DashPurchases>(           create: (context) => DashPurchases(             context.read<DashCounter>(),             context.read<FirebaseNotifier>(),           ),           lazy: false,         ), 

  User? get user => FirebaseAuth.instance.currentUser; 

  Future<bool> _verifyPurchase(PurchaseDetails purchaseDetails) async {     final url = Uri.parse('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;     }   } 

  Future<void> _onPurchaseUpdate(       List<PurchaseDetails> purchaseDetailsList) async {     for (var purchaseDetails in purchaseDetailsList) {       await _handlePurchase(purchaseDetails);     }     notifyListeners();   }    Future<void> _handlePurchase(PurchaseDetails purchaseDetails) async {     if (purchaseDetails.status == PurchaseStatus.purchased) {       // Send to server       var validPurchase = await _verifyPurchase(purchaseDetails);        if (validPurchase) {         // Apply changes locally         switch (purchaseDetails.productID) {           case storeKeySubscription:             counter.applyPaidMultiplier();           case storeKeyConsumable:             counter.addBoughtDashes(1000);          case storeKeyUpgrade:             _beautifiedDashUpgrade = true;         }       }     }      if (purchaseDetails.pendingCompletePurchase) {       await iapConnection.completePurchase(purchaseDetails);     }   } 

import 'products.dart';  /// Generic purchase handler, /// must be implemented for Google Play and Apple Store abstract class PurchaseHandler {    /// Verify if non-subscription purchase (aka consumable) is valid   /// and update the database   Future<bool> handleNonSubscription({     required String userId,     required ProductData productData,     required String token,   });    /// Verify if subscription purchase (aka non-consumable) is valid   /// and update the database   Future<bool> handleSubscription({     required String userId,     required ProductData productData,     required String token,   }); 

  /// Verify if purchase is valid and update the database   Future<bool> verifyPurchase({     required String userId,     required ProductData productData,     required String token,   }) async {     switch (productData.type) {       case ProductType.subscription:         return handleSubscription(           userId: userId,           productData: productData,           token: token,         );       case ProductType.nonSubscription:         return handleNonSubscription(           userId: userId,           productData: productData,           token: token,         );     }   } 

class ProductData {   final String productId;   final ProductType type;    const ProductData(this.productId, this.type); } 

enum ProductType {   subscription,   nonSubscription, } 

const productDataMap = {   'dash_consumable_2k': ProductData(     'dash_consumable_2k',     ProductType.nonSubscription,   ),   'dash_upgrade_3d': ProductData(     'dash_upgrade_3d',     ProductType.nonSubscription,   ),   'dash_subscription_doubler': ProductData(     'dash_subscription_doubler',     ProductType.subscription,   ), }; 

import 'dart:async';  import 'package:googleapis/androidpublisher/v3.dart' as ap;  import 'constants.dart'; import 'iap_repository.dart'; import 'products.dart'; import 'purchase_handler.dart';  class GooglePlayPurchaseHandler extends PurchaseHandler {   final ap.AndroidPublisherApi androidPublisher;   final IapRepository iapRepository;    GooglePlayPurchaseHandler(     this.androidPublisher,     this.iapRepository,   );    @override   Future<bool> handleNonSubscription({     required String? userId,     required ProductData productData,     required String token,   }) async {     return true;   }    @override   Future<bool> handleSubscription({     required String? userId,     required ProductData productData,     required String token,   }) async {     return true;   } } 

import 'dart:async';  import 'package:app_store_server_sdk/app_store_server_sdk.dart';  import 'constants.dart'; import 'iap_repository.dart'; import 'products.dart'; import 'purchase_handler.dart';  class AppStorePurchaseHandler extends PurchaseHandler {   final IapRepository iapRepository;    AppStorePurchaseHandler(     this.iapRepository,   );    @override   Future<bool> handleNonSubscription({     required String userId,     required ProductData productData,     required String token,   }) async {     return true;   }    @override   Future<bool> handleSubscription({     required String userId,     required ProductData productData,     required String token,   }) async {     return true;   } } 

import 'dart:convert'; // new  import 'package:firebase_backend_dart/helpers.dart'; import 'package:firebase_backend_dart/products.dart'; // new import 'package:shelf/shelf.dart'; // new import 'package:shelf_router/shelf_router.dart';  Future<void> main() async {   final router = Router();    final purchaseHandlers = await _createPurchaseHandlers();    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();     }   });    await serveHandler(router.call); }  ({   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');   } } 

import 'dart:convert'; import 'dart:io'; // new  import 'package:firebase_backend_dart/app_store_purchase_handler.dart'; // new import 'package:firebase_backend_dart/google_play_purchase_handler.dart'; // new import 'package:firebase_backend_dart/helpers.dart'; import 'package:firebase_backend_dart/iap_repository.dart'; // new import 'package:firebase_backend_dart/products.dart'; import 'package:firebase_backend_dart/purchase_handler.dart'; // new import 'package:googleapis/androidpublisher/v3.dart' as ap; // new import 'package:googleapis/firestore/v1.dart' as fs; // new import 'package:googleapis_auth/auth_io.dart' as auth; // new import 'package:shelf/shelf.dart'; import 'package:shelf_router/shelf_router.dart';  Future<Map<String, PurchaseHandler>> _createPurchaseHandlers() async {   // Configure Android Publisher API access   final serviceAccountGooglePlay =       File('assets/service-account-google-play.json').readAsStringSync();   final clientCredentialsGooglePlay =       auth.ServiceAccountCredentials.fromJson(serviceAccountGooglePlay);   final clientGooglePlay =       await auth.clientViaServiceAccount(clientCredentialsGooglePlay, [     ap.AndroidPublisherApi.androidpublisherScope,   ]);   final androidPublisher = ap.AndroidPublisherApi(clientGooglePlay);    // Configure Firestore API access   final serviceAccountFirebase =       File('assets/service-account-firebase.json').readAsStringSync();   final clientCredentialsFirebase =       auth.ServiceAccountCredentials.fromJson(serviceAccountFirebase);   final clientFirebase =       await auth.clientViaServiceAccount(clientCredentialsFirebase, [     fs.FirestoreApi.cloudPlatformScope,   ]);   final firestoreApi = fs.FirestoreApi(clientFirebase);   final dynamic json = jsonDecode(serviceAccountFirebase);   final projectId = json['project_id'] as String;   final iapRepository = IapRepository(firestoreApi, projectId);    return {     'google_play': GooglePlayPurchaseHandler(       androidPublisher,       iapRepository,     ),     'app_store': AppStorePurchaseHandler(       iapRepository,     ),   }; } 

  @override   Future<bool> handleNonSubscription({     required String? userId,     required ProductData productData,     required String token,   }) async {     print(       'GooglePlayPurchaseHandler.handleNonSubscription'       '($userId, ${productData.productId}, ${token.substring(0, 5)}...)',     );      try {       // Verify purchase with Google       final response = await androidPublisher.purchases.products.get(         androidPackageId,         productData.productId,         token,       );        print('Purchases response: ${response.toJson()}');        // Make sure an order id exists       if (response.orderId == null) {         print('Could not handle purchase without order id');         return false;       }       final orderId = response.orderId!;        final purchaseData = NonSubscriptionPurchase(         purchaseDate: DateTime.fromMillisecondsSinceEpoch(           int.parse(response.purchaseTimeMillis ?? '0'),         ),         orderId: orderId,         productId: productData.productId,         status: _nonSubscriptionStatusFrom(response.purchaseState),         userId: userId,         iapSource: IAPSource.googleplay,       );        // Update the database       if (userId != null) {         // If we know the userId,         // update the existing purchase or create it if it does not exist.         await iapRepository.createOrUpdatePurchase(purchaseData);       } else {         // If we do not know the user id, a previous entry must already         // exist, and thus we'll only update it.         await iapRepository.updatePurchase(purchaseData);       }       return true;     } on ap.DetailedApiRequestError catch (e) {       print(         'Error on handle NonSubscription: $e\n'         'JSON: ${e.jsonResponse}',       );     } catch (e) {       print('Error on handle NonSubscription: $e\n');     }     return false;   } 

  /// Handle subscription purchases.   ///   /// Retrieves the purchase status from Google Play and updates   /// the Firestore Database accordingly.   @override   Future<bool> handleSubscription({     required String? userId,     required ProductData productData,     required String token,   }) async {     print(       'GooglePlayPurchaseHandler.handleSubscription'       '($userId, ${productData.productId}, ${token.substring(0, 5)}...)',     );      try {       // Verify purchase with Google       final response = await androidPublisher.purchases.subscriptions.get(         androidPackageId,         productData.productId,         token,       );        print('Subscription response: ${response.toJson()}');        // Make sure an order id exists       if (response.orderId == null) {         print('Could not handle purchase without order id');         return false;       }       final orderId = extractOrderId(response.orderId!);        final purchaseData = SubscriptionPurchase(         purchaseDate: DateTime.fromMillisecondsSinceEpoch(           int.parse(response.startTimeMillis ?? '0'),         ),         orderId: orderId,         productId: productData.productId,         status: _subscriptionStatusFrom(response.paymentState),         userId: userId,         iapSource: IAPSource.googleplay,         expiryDate: DateTime.fromMillisecondsSinceEpoch(           int.parse(response.expiryTimeMillis ?? '0'),         ),       );        // Update the database       if (userId != null) {         // If we know the userId,         // update the existing purchase or create it if it does not exist.         await iapRepository.createOrUpdatePurchase(purchaseData);       } else {         // If we do not know the user id, a previous entry must already         // exist, and thus we'll only update it.         await iapRepository.updatePurchase(purchaseData);       }       return true;     } on ap.DetailedApiRequestError catch (e) {       print(         'Error on handle Subscription: $e\n'         'JSON: ${e.jsonResponse}',       );     } catch (e) {       print('Error on handle Subscription: $e\n');     }     return false;   } } 

NonSubscriptionStatus _nonSubscriptionStatusFrom(int? state) {   return switch (state) {     0 => NonSubscriptionStatus.completed,     2 => NonSubscriptionStatus.pending,     _ => NonSubscriptionStatus.cancelled,   }; }  SubscriptionStatus _subscriptionStatusFrom(int? state) {   return switch (state) {     // Payment pending     0 => SubscriptionStatus.pending,     // Payment received     1 => SubscriptionStatus.active,     // Free trial     2 => SubscriptionStatus.active,     // Pending deferred upgrade/downgrade     3 => SubscriptionStatus.pending,     // Expired or cancelled     _ => SubscriptionStatus.expired,   }; }  /// If a subscription suffix is present (..#) extract the orderId. String extractOrderId(String orderId) {   final orderIdSplit = orderId.split('..');   if (orderIdSplit.isNotEmpty) {     orderId = orderIdSplit[0];   }   return orderId; } 

  final _iTunesAPI = ITunesApi(     ITunesHttpClient(       ITunesEnvironment.sandbox(),       loggingEnabled: true,     ),   ); 

  @override   Future<bool> handleNonSubscription({     required String userId,     required ProductData productData,     required String token,   }) {     return handleValidation(userId: userId, token: token);   }    @override   Future<bool> handleSubscription({     required String userId,     required ProductData productData,     required String token,   }) {     return handleValidation(userId: userId, token: token);   }    /// Handle purchase validation.   Future<bool> handleValidation({     required String userId,     required String token,   }) async {    //..   } 

  /// Handle purchase validation.   Future<bool> handleValidation({     required String userId,     required String token,   }) async {     print('AppStorePurchaseHandler.handleValidation');     final response = await _iTunesAPI.verifyReceipt(       password: appStoreSharedSecret,       receiptData: token,     );     print('response: $response');     if (response.status == 0) {       final receipts = response.latestReceiptInfo ?? [];       for (final receipt in receipts) {         final product = productDataMap[receipt.productId];         if (product == null) {           print('Error: Unknown product: ${receipt.productId}');           continue;         }         switch (product.type) {           case ProductType.nonSubscription:             await iapRepository.createOrUpdatePurchase(NonSubscriptionPurchase(               userId: userId,               productId: receipt.productId ?? '',               iapSource: IAPSource.appstore,               orderId: receipt.originalTransactionId ?? '',               purchaseDate: DateTime.fromMillisecondsSinceEpoch(                   int.parse(receipt.originalPurchaseDateMs ?? '0')),               type: product.type,               status: NonSubscriptionStatus.completed,             ));             break;           case ProductType.subscription:             await iapRepository.createOrUpdatePurchase(SubscriptionPurchase(               userId: userId,               productId: receipt.productId ?? '',               iapSource: IAPSource.appstore,               orderId: receipt.originalTransactionId ?? '',               purchaseDate: DateTime.fromMillisecondsSinceEpoch(                   int.parse(receipt.originalPurchaseDateMs ?? '0')),               type: product.type,               expiryDate: DateTime.fromMillisecondsSinceEpoch(                   int.parse(receipt.expiresDateMs ?? '0')),               status: SubscriptionStatus.active,             ));             break;         }       }       return true;     } else {       print('Error: Status: ${response.status}');       return false;     }   } 

$ dart bin/server.dart  Serving at http://0.0.0.0:8080 

import 'package:googleapis/pubsub/v1.dart' as pubsub; 

class GooglePlayPurchaseHandler extends PurchaseHandler {   final ap.AndroidPublisherApi androidPublisher;   final IapRepository iapRepository;   final pubsub.PubsubApi pubsubApi; // new    GooglePlayPurchaseHandler(     this.androidPublisher,     this.iapRepository,     this.pubsubApi, // new   ) {     // Poll messages from Pub/Sub every 10 seconds     Timer.periodic(Duration(seconds: 10), (_) {       _pullMessageFromPubSub();     });   } 

  /// Process messages from Google Play   /// Called every 10 seconds   Future<void> _pullMessageFromPubSub() async {     print('Polling Google Play messages');     final request = pubsub.PullRequest(       maxMessages: 1000,     );     final topicName =         'projects/$googlePlayProjectName/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);       }     }   }    Future<void> _processMessage(String data64, String? ackId) async {     final dataRaw = utf8.decode(base64Decode(data64));     print('Received data: $dataRaw');     final dynamic data = jsonDecode(dataRaw);     if (data['testNotification'] != null) {       print('Skip test messages');       if (ackId != null) {         await _ackMessage(ackId);       }       return;     }     final dynamic subscriptionNotification = data['subscriptionNotification'];     final dynamic oneTimeProductNotification =         data['oneTimeProductNotification'];     if (subscriptionNotification != null) {       print('Processing Subscription');       final subscriptionId =           subscriptionNotification['subscriptionId'] as String;       final purchaseToken = subscriptionNotification['purchaseToken'] as String;       final productData = productDataMap[subscriptionId]!;       final result = await handleSubscription(         userId: null,         productData: productData,         token: purchaseToken,       );       if (result && ackId != null) {         await _ackMessage(ackId);       }     } else if (oneTimeProductNotification != null) {       print('Processing NonSubscription');       final sku = oneTimeProductNotification['sku'] as String;       final purchaseToken =           oneTimeProductNotification['purchaseToken'] as String;       final productData = productDataMap[sku]!;       final result = await handleNonSubscription(         userId: null,         productData: productData,         token: purchaseToken,       );       if (result && ackId != null) {         await _ackMessage(ackId);       }     } else {       print('invalid data');     }   }    /// ACK Messages from Pub/Sub   Future<void> _ackMessage(String id) async {     print('ACK Message');     final request = pubsub.AcknowledgeRequest(       ackIds: [id],     );     final subscriptionName =         'projects/$googlePlayProjectName/subscriptions/$googlePlayPubsubBillingTopic-sub';     await pubsubApi.projects.subscriptions.acknowledge(       request,       subscriptionName,     );   } 

 final clientGooglePlay =       await auth.clientViaServiceAccount(clientCredentialsGooglePlay, [     ap.AndroidPublisherApi.androidpublisherScope,     pubsub.PubsubApi.cloudPlatformScope, // new   ]); 

  final pubsubApi = pubsub.PubsubApi(clientGooglePlay); 

  return {     'google_play': GooglePlayPurchaseHandler(       androidPublisher,       iapRepository,       pubsubApi, // new     ),     'app_store': AppStorePurchaseHandler(       iapRepository,     ),   }; 

final AppStoreServerAPI appStoreServerAPI;  AppStorePurchaseHandler(   this.iapRepository,   this.appStoreServerAPI, // new ) 

  AppStorePurchaseHandler(     this.iapRepository,     this.appStoreServerAPI,   ) {     // Poll Subscription status every 10 seconds.     Timer.periodic(Duration(seconds: 10), (_) {       _pullStatus();     });   } 

  Future<void> _pullStatus() async {     print('Polling App Store');     final purchases = await iapRepository.getPurchases();     // filter for App Store subscriptions     final appStoreSubscriptions = purchases.where((element) =>         element.type == ProductType.subscription &&         element.iapSource == IAPSource.appstore);     for (final purchase in appStoreSubscriptions) {       final status =           await appStoreServerAPI.getAllSubscriptionStatuses(purchase.orderId);       // Obtain all subscriptions for the order id.       for (final subscription in status.data) {         // Last transaction contains the subscription status.         for (final transaction in subscription.lastTransactions) {           final expirationDate = DateTime.fromMillisecondsSinceEpoch(               transaction.transactionInfo.expiresDate ?? 0);           // Check if subscription has expired.           final isExpired = expirationDate.isBefore(DateTime.now());           print('Expiration Date: $expirationDate - isExpired: $isExpired');           // Update the subscription status with the new expiration date and status.           await iapRepository.updatePurchase(SubscriptionPurchase(             userId: null,             productId: transaction.transactionInfo.productId,             iapSource: IAPSource.appstore,             orderId: transaction.originalTransactionId,             purchaseDate: DateTime.fromMillisecondsSinceEpoch(                 transaction.transactionInfo.originalPurchaseDate),             type: ProductType.subscription,             expiryDate: expirationDate,             status: isExpired                 ? SubscriptionStatus.expired                 : SubscriptionStatus.active,           ));         }       }     }   } 

  // add from here   final subscriptionKeyAppStore =       File('assets/SubscriptionKey.p8').readAsStringSync();    // Configure Apple Store API access   var appStoreEnvironment = AppStoreEnvironment.sandbox(     bundleId: bundleId,     issuerId: appStoreIssuerId,     keyId: appStoreKeyId,     privateKey: subscriptionKeyAppStore,   );    // Stored token for Apple Store API access, if available   final file = File('assets/appstore.token');   String? appStoreToken;   if (file.existsSync() && file.lengthSync() > 0) {     appStoreToken = file.readAsStringSync();   }    final appStoreServerAPI = AppStoreServerAPI(     AppStoreServerHttpClient(       appStoreEnvironment,       jwt: appStoreToken,       jwtTokenUpdatedCallback: (token) {         file.writeAsStringSync(token);       },     ),   );   // to here     return {     'google_play': GooglePlayPurchaseHandler(       androidPublisher,       iapRepository,       pubsubApi,     ),     'app_store': AppStorePurchaseHandler(       iapRepository,       appStoreServerAPI, // new     ),   }; 

  void updatePurchases() {     _purchaseSubscription?.cancel();     var user = _user;     if (user == null) {       purchases = [];       hasActiveSubscription = false;       hasUpgrade = false;       return;     }     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();     });   } 

  IAPRepo iapRepo;    DashPurchases(this.counter, this.firebaseNotifier, this.iapRepo) {     final purchaseUpdated = iapConnection.purchaseStream;     _subscription = purchaseUpdated.listen(       _onPurchaseUpdate,       onDone: _updateStreamOnDone,       onError: _updateStreamOnError,     );     iapRepo.addListener(purchasesUpdate);     loadPurchases();   }    @override   void dispose() {     _subscription.cancel();     iapRepo.removeListener(purchasesUpdate);     super.dispose();   }    void purchasesUpdate() {     //TODO manage updates   } 

        ChangeNotifierProvider<DashPurchases>(           create: (context) => DashPurchases(             context.read<DashCounter>(),             context.read<FirebaseNotifier>(),             context.read<IAPRepo>(),           ),           lazy: false,         ), 

  void purchasesUpdate() {     var subscriptions = <PurchasableProduct>[];     var upgrades = <PurchasableProduct>[];     // Get a list of purchasable products for the subscription and upgrade.     // This should be 1 per type.     if (products.isNotEmpty) {       subscriptions = products           .where((element) => element.productDetails.id == storeKeySubscription)           .toList();       upgrades = products           .where((element) => element.productDetails.id == storeKeyUpgrade)           .toList();     }      // Set the subscription in the counter logic and show/hide purchased on the     // purchases page.     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);       }     }      // Set the Dash beautifier and show/hide purchased on     // the purchases page.     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 != ProductStatus.purchased) {       product.status = ProductStatus.purchased;       notifyListeners();     }   }