Flutter 有人能帮我使用in_app_purchase插件吗？

你好！我正在尝试配置非耗材产品。我什么时候和为什么要完成购买以及我什么时候和为什么要消费购买？而且，我无法在两个平台上都实现这一点

我正在使用应用程序内购买：^0.5.1+3插件和以下环境：

[✓] 颤振（通道稳定，2.0.4，在macOS 11.2.2 20D80 darwin-x64上，现场en-BY）

[✓] Android工具链-为Android设备开发（Android SDK版本30.0.2）

[✓] Xcode-为iOS和macOS开发

[✓] Chrome-为web开发

[✓] Android Studio（4.1版）

[✓] VS代码（版本1.55.0）

[✓] 已连接的设备（1个可用）

如果有人能帮我编写代码，那就太好了。

import 'dart:async';
import 'dart:io';

import 'package:collection/collection.dart';
import 'package:flutter/material.dart';
import 'package:in_app_purchase/in_app_purchase.dart';
import 'package:in_app_purchase/store_kit_wrappers.dart';

const myProductId = 'remove_ads';

class PaymentProvider with ChangeNotifier {
  final _iap = InAppPurchaseConnection.instance;

  StreamSubscription<List<PurchaseDetails>> subscription;
  bool isAvailable = false;
  bool initialized = false;

  bool _isPurchased = false;
  bool get isPurchased => _isPurchased;
  set isPurchased(bool value) {
    _isPurchased = value;
    notifyListeners();
  }

  bool _isPurchasePending = false;
  bool get isPurchasePending => _isPurchasePending;
  set isPurchasePending(bool value) {
    _isPurchasePending = value;
    notifyListeners();
  }

  List<ProductDetails> _products = [];
  List<ProductDetails> get products => _products;
  set products(List value) {
    _products = value;
    notifyListeners();
  }

  List<PurchaseDetails> _purchases = [];
  List<PurchaseDetails> get purchases => _purchases;
  set purchases(List value) {
    _purchases = value;
    notifyListeners();
  }

  Future<void> initialize() async {
    isAvailable = await _iap.isAvailable();

    if (isAvailable) {
      await Future.wait([
        _getProducts(),
        _getPastPurchases(),
      ]);

      await restorePurchase();

      subscription = _iap.purchaseUpdatedStream.listen(
        _listenToPurchaseUpdated,
        onDone: () {
          subscription?.cancel();
        },
      );

      initialized = true;
      notifyListeners();
    }
  }

  void _listenToPurchaseUpdated(List<PurchaseDetails> purchaseDetailsList) {
    purchaseDetailsList.forEach((purchaseDetails) async {
      switch (purchaseDetails.status) {
        case PurchaseStatus.pending:
          isPurchasePending = true;
          break;
        case PurchaseStatus.error:
          if (Platform.isIOS) await _iap.completePurchase(purchaseDetails);
          isPurchasePending = false;
          break;
        case PurchaseStatus.purchased:
          var valid = await _verifyPurchase(purchaseDetails);

          if (valid) {
            _deliverProduct(purchaseDetails);
          } else {
            _handleInvalidPurchase(purchaseDetails);
          }
          break;
        default:
          break;
      }
    });
  }

  Future<bool> _verifyPurchase(PurchaseDetails purchaseDetails) async {
    /// ???
    return Future<bool>.value(true);
  }

  void _deliverProduct(PurchaseDetails purchaseDetails) async {
    if (purchaseDetails.productID != myProductId) {
      purchases.add(purchaseDetails);
    }

    if (purchaseDetails.pendingCompletePurchase) {
      await _iap.completePurchase(purchaseDetails);
    }

    if (Platform.isAndroid) {
      if (purchaseDetails.productID == myProductId) {
        await _iap.consumePurchase(purchaseDetails);
      }
    }

    isPurchased = true;
    isPurchasePending = false;
  }

  void _handleInvalidPurchase(PurchaseDetails purchaseDetails) {
    /// ???
  }

  Future<void> restorePurchase() async {
    // if (Platform.isIOS) {
    //   await SKPaymentQueueWrapper().restoreTransactions();
    // }

    var purchase = hasPurchased(myProductId);

    if (purchase != null && purchase.status == PurchaseStatus.purchased) {
      await _iap.completePurchase(purchase);
      isPurchased = true;
    }
  }

  PurchaseDetails hasPurchased(String productId) {
    return purchases.firstWhereOrNull((_) => _.productID == productId);
  }

  Future<void> purchaseRemoveAds(ProductDetails product) async {
    if (Platform.isIOS) {
      var transactions = await SKPaymentQueueWrapper().transactions();

      await Future.forEach(transactions, (transaction) async {
        await SKPaymentQueueWrapper().finishTransaction(transaction);
      });
    }

    var purchaseParam = PurchaseParam(
      productDetails: product,
    );

    await _iap.buyNonConsumable(purchaseParam: purchaseParam);
  }

  Future<void> _getProducts() async {
    var response = await _iap.queryProductDetails({myProductId});
    products = response.productDetails;
  }

  Future<void> _getPastPurchases() async {
    var purchaseResponse = await _iap.queryPastPurchases();

    if (purchaseResponse.error != null) {
      // handle query past purchase error..
    }

    for (var purchase in purchaseResponse.pastPurchases) {
      if (purchase.pendingCompletePurchase) {
        await _iap.completePurchase(purchase);
      }

      if (Platform.isAndroid && purchase.status == PurchaseStatus.purchased) {
        await _iap.consumePurchase(purchase);
      }
    }

    purchases = purchaseResponse.pastPurchases;
  }
}

导入'dart:async'；
导入“dart:io”；
导入“package:collection/collection.dart”；
进口“包装：颤振/材料.省道”；
导入“包：应用程序内购买/应用程序内购买.dart”；
导入“package:in_app_purchase/store_kit_wrappers.dart”；
const myProductId='remove_ads'；
使用ChangeNotifier类PaymentProvider{
final _iap=InAppPurchaseConnection.instance；
流媒体订阅；
bool isAvailable=false；
bool初始化=false；
bool_isPurchased=假；
bool get isPurchased=>\u isPurchased；
设置isPurchased（布尔值）{
_i采购=价值；
notifyListeners（）；
}
bool\u isPurchasePending=false；
bool get isPurchasePending=>\u isPurchasePending；
设置isPurchasePending（布尔值）{
_isPurchasePending=值；
notifyListeners（）；
}
列表_产品=[]；
列表获取产品=>\u产品；
设置产品（列表值）{
_产品=价值；
notifyListeners（）；
}
清单_采购=[]；
列表获取采购=>\u采购；
设置采购（列表值）{
_购买=价值；
notifyListeners（）；
}
Future initialize（）异步{
isAvailable=等待_iap.isAvailable（）；
如果（可用）{
等待未来([
_getProducts（），
_getPastPurchases（），
]);
等待恢复采购（）；
订阅=\u iap.purchaseUpdatedStream.listen(
_ListentPurchaseUpdated，
onDone:（）{
订阅？.cancel（）；
},
);
初始化=真；
notifyListeners（）；
}
}
void _listenToPurchaseUpdated（列表purchaseDetailsList）{
forEach（（purchaseDetails）异步{
开关（purchaseDetails.status）{
案例PurchaseStatus.pending：
isPurchasePending=true；
打破
案例PurchaseStatus.error：
if（平台isIOS）等待完成采购（采购详情）；
isPurchasePending=false；
打破
案例PurchaseStatus.purchased：
var valid=等待验证采购（采购详情）；
如果（有效）{
_交付产品（采购详情）；
}否则{
_handleInvalidPurchase（采购详情）；
}
打破
违约：
打破
}
});
}
未来验证购买（PurchaseDetails PurchaseDetails）异步{
/// ???
返回未来值（true）；
}
void\u deliverProduct（PurchaseDetails PurchaseDetails）异步{
if（purchaseDetails.productID！=myProductId）{
采购。添加（采购详情）；
}
if（purchaseDetails.pendingCompletePurchase）{
等待完成采购（采购详情）；
}
if（Platform.isAndroid）{
if（purchaseDetails.productID==myProductId）{
等待消费者购买（购买详情）；
}
}
isPurchased=true；
isPurchasePending=false；
}
无效_handleInvalidPurchase（采购详情采购详情）{
/// ???
}
Future restorePurchase（）异步{
//if（Platform.isIOS）{
//等待SKPaymentQueueWrapper（）.restoreTransactions（）；
// }
var purchase=HasPurchase（myProductId）；
if（purchase！=null&&purchase.status==PurchaseStatus.purchased）{
等待完成采购（采购）；
isPurchased=true；
}
}
PurchaseDetails hasPurchased（字符串productId）{
退货采购.firstWhereOrNull（（）=>productID==productID）；
}
未来的purchaseRemoveAds（ProductDetails产品）异步{
if（Platform.isIOS）{
var transactions=wait SKPaymentQueueWrapper（）.transactions（）；
等待未来。forEach（事务，（事务）异步{
等待SKPaymentQueueWrapper（）.finishTransaction（事务）；
});
}
var purchaseParam=purchaseParam(
productDetails:product，
);
等待购买非消费品（purchaseParam:purchaseParam）；
}
Future\u getProducts（）异步{
var response=await_iap.queryProductDetails（{myProductId}）；
products=response.productDetails；
}
Future\u getPastPurchases（）异步{
var purchaseResponse=await_iap.queryPastPurchases（）；
if（purchaseResponse.error！=null）{
//处理查询过去的购买错误。。
}
for（purchaseResponse.pastPurchases中的var购买）{
if（采购.待完成采购）{
等待完成采购（采购）；
}
if（Platform.isAndroid&&purchase.status==PurchaseStatus.purchased）{
等待消费者购买（购买）；
}
}
采购=purchaseResponse.pastPurchases；
}
}