Appodeal 同意管理器不会显示

Question

  Future<void> checkConsent() async {
    ConsentManager.requestConsentInfoUpdate(Constants.kAppodealKey);

    ConsentManager.setConsentInfoUpdateListener(
        (onConsentInfoUpdated, consent) {
      print('PRINT: onConsentInfoUpdated $consent');
    }, (onFailedToUpdateConsentInfo, error) {
      print('PRINT: onFailedToUpdateConsentInfo $error');
    });

    var consentStatus = await ConsentManager.getConsentStatus();
    print('PRINT: consentStatus $consentStatus');
    if (consentStatus.toString() == 'Status.UNKNOWN') {
      var shouldShow = await ConsentManager.shouldShowConsentDialog();
      print('PRINT: shouldShow $shouldShow');

      if (shouldShow.toString() == 'ShouldShow.TRUE') {
        ConsentManager.loadConsentForm();

        var isLoaded = await ConsentManager.consentFormIsLoaded();
        print('PRINT: isLoaded $isLoaded');
        if (isLoaded == true) {
          ConsentManager.showAsDialogConsentForm();
          ConsentManager.showAsActivityConsentForm();

          ConsentManager.setConsentFormListener((onConsentFormLoaded) {
            print('PRINT: onConsentFormLoaded');
          }, (onConsentFormError, error) {
            print('PRINT: onConsentFormError $error');
          }, (onConsentFormOpened) {
            print('PRINT: onConsentFormOpened');
          }, (onConsentFormClosed, consent) {
            print('PRINT: onConsentFormClosed $consent');
          });
        }
      }
    }
  }

Constants.kAppodealKey 是我从这里获得的应用程序密钥：https://app.appodeal.com/apps

但这就是我得到的：

I/flutter ( 9497): PRINT: consentStatus Status.UNKNOWN
I/flutter ( 9497): PRINT: shouldShow ShouldShow.UNKNOWN

在文档中，ShouldShow.UKNOWN 表示：https://wiki.appodeal.com/en/android/get-started/data-protection/gdpr-and-ccpa

UNKNOWN The value is undefined(the requestConsentInfoUpdate method was not called).

但我已经在方法的第一行调用了它。我可以知道它为什么会出现问题吗？

Answer 1

我能够使用您的代码、我验证的应用密钥以及在应用安装后的第一次尝试时的打印结果重现您的问题：

I/flutter (21755): PRINT: consentStatus Status.UNKNOWN
I/flutter (21755): PRINT: shouldShow ShouldShow.UNKNOWN
I/flutter (21755): PRINT: onConsentInfoUpdated {"createdAt":1655890242,"zone":"NONE","acceptedVendors":[],"iab":{"IABConsent_SubjectToGDPR":"0"},"updatedAt":1655890242,"status":"UNKNOWN"}

这里的主要问题是你不能依靠方法调用的执行结束来认为它的工作已经完成。即使是await。

您必须依赖重试和等待循环，我不建议这样做，因为它可能很密集并且很容易失败。 或者你可以依赖听众。

我所做的是两者兼而有之，因为听众并不总是可用的。

我很想获得有关此提案的一些反馈，因为我不确定我是否正确解释了 AppoDeal 文档。

加载应用后，我会致电AdManager.init();。如果更早调用，这也可能有效。

import 'dart:convert';

import 'package:flutter/foundation.dart';
import 'package:permission_handler/permission_handler.dart';
import 'package:stack_appodeal_flutter/stack_appodeal_flutter.dart';
import 'dart:io' show Platform;

class AdManager {
  static var consent = false;
  static Status consentStatus = Status.UNKNOWN;
  static int requestConsentInfoUpdateRetries = 20;
  static int requestLoadConsentFormRetries = 20;
  static int adType = Appodeal.INTERSTITIAL;

  static String get appKey =>
      Platform.isAndroid ?
      "your android app key"
          :
      "your ios app key"
  ;
  //app ids found here: https://app.appodeal.com/apps

  static initializeAfterConsent() {
    Appodeal.initialize(
      appKey,
      [
        adType,
      ],
      boolConsent: consent,
    ).whenComplete(() {
      Appodeal.isLoaded(adType).then((bool isLoaded) {
        if (!isLoaded) {
          Appodeal.cache(adType).whenComplete(() {
            debugPrint("Note: appodeal ad has been loaded");
          });
        }
        else {
          debugPrint("Note: appodeal ad was loaded");
        }
      });
    });
  }

  static init(bool testing) async {
    try {
      await handleATT();
      await Appodeal.setTesting(true);
      await Appodeal.setLogLevel(Appodeal.LogLevelVerbose);
      await Appodeal.disableNetwork("admob");
      await Appodeal.setAutoCache(adType, true);
      await Appodeal.setAutoCache(Appodeal.REWARDED_VIDEO, false);
      await Appodeal.setAutoCache(Appodeal.BANNER, false);
      await Appodeal.setAutoCache(Appodeal.MREC, false);
      await Appodeal.setChildDirectedTreatment(false);
      await Appodeal.setUseSafeArea(true);
      await Appodeal.muteVideosIfCallsMuted(true);
      await doTheConsentStuff();
    }
    catch (e, st) {
      debugPrint("Error initializing ads: ${e.toString()} ${st.toString()}");
    }
  }


  static Future<String> showInterstitialAd(
      {Function doWhenComplete, int retries = 10}) async {
    try {
      Map<String, Function> callsForAd = {
        "not initialized": () async {
          return await Appodeal.isInitialized(adType);
        },
        "not loaded": () async {
          return await Appodeal.isLoaded(adType);
        },
        "cannot show": () async {
          return await Appodeal.canShow(adType);
        },
        "not shown": () async {
          return await Appodeal.show(adType);
        },
      };
      for (int i = 0; i < callsForAd.length; i++) {
        if (!await callsForAd.values.toList()[i]()) {
          String res = callsForAd.keys.toList()[i];
          switch (res) {
            case "not initialized":
              await initializeAfterConsent();
              break;
            case "not loaded":
              await Appodeal.cache(adType);
              break;
            case "cannot show":
            case "not shown":
              if (retries > 0) {
                await Future.delayed(Duration(milliseconds: 100));
              }
              break;
            default:
              return (res);
              break;
          }
          if (retries > 0) {
            debugPrint(
                "Warning from ads: " + res + "; with retries: $retries");
            return (await showInterstitialAd(
                doWhenComplete: doWhenComplete, retries: retries - 1));
          }
          return (res);
        }
        else {
          if (doWhenComplete != null) {
            doWhenComplete();
          }
        }
      }
      return (null);
    }
    catch (e, st) {
      return ("${e.toString()} ${st.toString()}");
    }
  }

  static retryMaybeConsentInfoUpdate() {
    if (requestConsentInfoUpdateRetries > 0) {
      Future.delayed(Duration(milliseconds: 2000)).whenComplete(() {
        requestConsentInfoUpdateRetries--;
        ConsentManager.requestConsentInfoUpdate(appKey);
      });
    }
    else {
      debugPrint(
          "Error: exhausted all retries on retryMaybeConsentInfoUpdate, aborting consent handling");
      initializeAfterConsent();
    }
  }

  static retryMaybeLoadConsentForm() {
    if (requestLoadConsentFormRetries > 0) {
      Future.delayed(Duration(milliseconds: 2000)).whenComplete(() {
        requestLoadConsentFormRetries--;
        ConsentManager.loadConsentForm();
      });
    }
    else {
      debugPrint(
          "Error: exhausted all retries on requestLoadConsentFormRetries, aborting consent handling");
      initializeAfterConsent();
    }
  }

  static doTheConsentStuff() async {
    try {
      ConsentManager.setConsentInfoUpdateListener(
              (onConsentInfoUpdated, consent) {
            debugPrint(
                "Note: Appodeal consent onConsentInfoUpdated: $onConsentInfoUpdated : $consent");
            if (onConsentInfoUpdated == "onConsentInfoUpdated") {
              try {
                Map<String, dynamic> result = jsonDecode(consent);
                switch (result["status"]) {
                  case "UNKNOWN":
                    debugPrint("Note: got a consent info status of unknown");
                    updateConsentStatus().whenComplete(() {
                      getShouldShow().then((shouldShow) {
                        switch (shouldShow) {
                          case ShouldShow.TRUE:
                            ConsentManager.setConsentFormListener(
                                    (onConsentFormLoaded) {
                                  debugPrint(
                                      "Note: consent form loaded: $onConsentFormLoaded");
                                  if (Platform.isIOS) {
                                    ConsentManager.showAsActivityConsentForm();
                                  }
                                  else {
                                    ConsentManager.showAsDialogConsentForm();
                                  }
                                },
                                    (onConsentFormError, error) {
                                  debugPrint(
                                      "Error: consent form error: $onConsentFormError: $error");
                                  if (error == "Nothing to load") {
                                    updateConsentStatus().whenComplete(() {
                                      initializeAfterConsent();
                                    });
                                  }
                                  else {
                                    retryMaybeLoadConsentForm();
                                  }
                                },
                                    (onConsentFormOpened) {
                                  debugPrint(
                                      "Note: consent form opened: $onConsentFormOpened");
                                },
                                    (onConsentFormClosed, consent) {
                                  debugPrint(
                                      "Note: consent form closed: $onConsentFormClosed: $consent");
                                  updateConsentStatus().whenComplete(() {
                                    initializeAfterConsent();
                                  });
                                }
                            );
                            ConsentManager.loadConsentForm();
                            break;
                          case ShouldShow.FALSE:
                            debugPrint("Note: no need to show consent form");
                            updateConsentStatus().whenComplete(() {
                              initializeAfterConsent();
                            });
                            break;
                          case ShouldShow.UNKNOWN:
                            retryMaybeConsentInfoUpdate();
                            break;
                          default:
                            debugPrint(
                                "Error: undefined consent shouldShow value, aborting consent handling");
                            initializeAfterConsent();
                            break;
                        }
                      });
                    });
                    break;
                  case "PARTLY_PERSONALIZED":
                    debugPrint(
                        "Note: got a consent info status of PARTLY_PERSONALIZED");
                    updateConsentStatus().whenComplete(() {
                      initializeAfterConsent();
                    });
                    break;
                  case "PERSONALIZED":
                    debugPrint(
                        "Note: got a consent info status of PERSONALIZED");
                    updateConsentStatus().whenComplete(() {
                      initializeAfterConsent();
                    });
                    break;
                  case "NON_PERSONALIZED":
                    debugPrint(
                        "Note: got a consent info status of NON_PERSONALIZED");
                    updateConsentStatus().whenComplete(() {
                      initializeAfterConsent();
                    });
                    break;
                  default:
                    debugPrint("Error: got an unknown consent info status");
                    retryMaybeConsentInfoUpdate();
                    break;
                }
              }
              catch (e, st) {
                debugPrint("Error reading onConsentInfoUpdated data");
                retryMaybeConsentInfoUpdate();
              }
            }
          },
              (onFailedToUpdateConsentInfo, error) {
            debugPrint(
                "Note: Appodeal consent onFailedToUpdateConsentInfo: $onFailedToUpdateConsentInfo : $error with $requestConsentInfoUpdateRetries retries");
            retryMaybeConsentInfoUpdate();
          });
      await ConsentManager.requestConsentInfoUpdate(appKey);
    }
    catch (e, st) {
      debugPrint("Error: consent form general error: ${e.toString()} ${st
          .toString()}");
    }
  }

  static Future<void> updateConsentStatus() async {
    consentStatus = await ConsentManager.getConsentStatus();
    switch (consentStatus) {
      case Status.UNKNOWN:
        debugPrint("Warning: consent status is unknown");
        consent = false;
        break;
      case Status.NON_PERSONALIZED:
      case Status.PARTLY_PERSONALIZED:
        consent = false;
        break;
      case Status.PERSONALIZED:
        debugPrint("Note: consent status is known");
        consent = true;
        break;
      default:
        consent = false;
        debugPrint("Warning: undefined consent status");
        break;
    }
  }

  static Future<ShouldShow> getShouldShow([int retries = 20]) async {
    var shouldShow = await ConsentManager.shouldShowConsentDialog();
    if (shouldShow == ShouldShow.UNKNOWN) {
      if (retries > 0) {
        await Future.delayed(Duration(milliseconds: 500));
        return (getShouldShow(retries - 1));
      }
    }
    return (shouldShow);
  }

  static Future<void> handleATT({int retries = 20}) async {
    if (Platform.isIOS) {
      Permission appTrackingTransparencyPermission = Permission
          .appTrackingTransparency;
      PermissionStatus aTTPermissionStatus = await appTrackingTransparencyPermission
          .status;
      if (aTTPermissionStatus == null ||
          aTTPermissionStatus == PermissionStatus.denied) {
        debugPrint("ATT is null or denied, requesting with retries: $retries");
        aTTPermissionStatus = await appTrackingTransparencyPermission.request();
        if (aTTPermissionStatus == null ||
            aTTPermissionStatus == PermissionStatus.denied) {
          if (retries > 0) {
            await Future.delayed(Duration(milliseconds: 500));
            await handleATT(retries: retries - 1);
          }
          else {
            debugPrint(
                "Warning: ATT permission request retries exhausted, aborting");
          }
        }
        return;
      }
      debugPrint(
          "ATT is either granted, permanently denied, limited or restricted, thus, not requesting");
    }
  }
}

有了这个代码，我得到了这个经过编辑的同意书：

然后，当我请求展示广告时，会显示以下内容：

所以，对我来说，除了弃用警告之外，一切似乎都正常。

编辑 2022 06 23： 在 iOS 上运行，我意识到 shouldShow 的答案足以知道是否显示同意书。因此，同意书仅在我的 VPN 设置为欧洲或加利福尼亚时显示。 同样对于 iOS，我添加了 ATT 处理。 我还做了一些其他一般性的改进。

我不为 Appodeal 工作，也不是法律专家。我只是根据我个人的理解提供此代码，这可能不会导致处理这些广告和同意问题的正确方法。