Começar

De acordo com a Política de consentimento de usuários da União Europeia do Google, você precisa divulgar algumas informações aos seus usuários no Espaço Econômico Europeu (EEE) e no Reino Unido, além de receber o consentimento deles para usar cookies ou outro armazenamento local, quando exigido por lei, e usar dados pessoais (como ID de publicidade) para veicular anúncios. Essa política reflete os requisitos da Diretiva de privacidade eletrônica da UE e do Regulamento geral de proteção de dados (GDPR).

Para ajudar os editores a cumprir as obrigações determinadas por essa política, o Google oferece o SDK da plataforma de mensagens aos usuários (UMP, na sigla em inglês). O SDK da UMP foi atualizado para ser compatível com os padrões mais recentes do IAB. Todas essas configurações agora podem ser processadas de maneira conveniente em Ad Manager Privacidade e mensagens.

Pré-requisitos

• ler o Guia explicativo

• Se você estiver trabalhando em requisitos relacionados ao GDPR, leia Como os requisitos do IAB afetam as mensagens de consentimento para a União Europeia

Criar um tipo de mensagem

Crie mensagens para os usuários com um dos Tipos de mensagem de usuário disponíveis na guia Privacidade e mensagens da sua Ad Manager . O SDK da UMP tenta exibir uma mensagem de usuário criada a partir do Ad Manager ID do aplicativo definido no seu projeto. Se nenhuma mensagem for configurada para o aplicativo, o SDK retornará um erro.

Para mais detalhes, consulte Sobre privacidade e mensagens.

Solicitação de informações de consentimento

Solicite uma atualização das informações de consentimento do usuário a cada inicialização do app usando requestConsentInfoUpdate(). Isso determina se o usuário precisa dar consentimento caso ainda não tenha feito isso ou tenha expirado.

Confira um exemplo de como verificar o status da inicialização do app:

@override
void initState() {
  super.initState();

  // Create a ConsentRequestParameters object.
  final params = ConsentRequestParameters();

  // Request an update for the consent information.
  ConsentInformation.instance.requestConsentInfoUpdate(
    params,
    () async {
      // TODO: Load and present the consent form.
    },
    (FormError error) {
      // Handle the error.
    },
  );
}

Aviso :o uso de outras formas de verificar o status de consentimento, como o cache do app ou uma string salva anteriormente, pode resultar em um erro do TCF 3.3 se o consentimento tiver expirado.

Carregar e mostrar um formulário de consentimento, se necessário

Importante :as APIs a seguir são compatíveis com o SDK da UMP versão 2.1.0 ou mais recente.

Depois de receber o status de consentimento mais atualizado, chameloadAndShowConsentFormIfRequired() na classeConsentForm para carregar um formulário de consentimento. Se o status de consentimento for obrigatório, o SDK carregará um formulário e o apresentará imediatamente a partir do fornecido. O método callback é chamado depois que o formulário é dispensado. Se o consentimento não for necessário, a consulta callback imediatamente.

@override
void initState() {
  super.initState();

  // Create a ConsentRequestParameters object.
  final params = ConsentRequestParameters();

  // Request an update for the consent information.
  ConsentInformation.instance.requestConsentInfoUpdate(
    params,
    () async {
      ConsentForm.loadAndShowConsentFormIfRequired((loadAndShowError) {
        if (loadAndShowError != null) {
          // Consent gathering failed.
        }

        // Consent has been gathered.
      });
    },
    (FormError error) {
      // Handle the error.
    },
  );
}

Se você precisar realizar qualquer ação depois que o usuário fizer uma escolha ou dispensar o formulário, coloque essa lógica na callback do formulário.

Solicitar anúncios

Antes de solicitar anúncios no seu app, verifique se você recebeu o consentimento do usuário que utiliza canRequestAds(). Há dois locais a serem verificados ao obter o consentimento:

1. Quando o consentimento for recebido na sessão atual.
2. Imediatamente após você ter chamado requestConsentInfoUpdate(). É possível que o consentimento tenha sido dado na sessão anterior. Como prática recomendada de latência, não espere a conclusão do callback para poder começar a carregar anúncios o mais rápido possível após o início do aplicativo.

Observação: canRequestAds() sempre retorna false até que você chame requestConsentInfoUpdate()

Se ocorrer um erro durante o processo de solicitação de consentimento, tente solicitar anúncios. O SDK da UMP usa o status de consentimento da sessão anterior.

class AppExampleState extends State<AppExample> {

  // Use a bool to initialize the Mobile Ads SDK and load ads once.
  var _isMobileAdsInitializeCalled = false;

  @override
  void initState() {
    super.initState();

    // Create a ConsentRequestParameters object.
    final params = ConsentRequestParameters();

    // Request an update for the consent information.
    ConsentInformation.instance.requestConsentInfoUpdate(
      params,
      () async {
        ConsentForm.loadAndShowConsentFormIfRequired((loadAndShowError) {
          if (loadAndShowError != null) {
            // Consent gathering failed.
          }

          // Consent has been gathered.
          _initializeMobileAdsSDK();
        });
      },
      (FormError error) {
        // Handle the error.
      },
    );

    // Check if you can initialize the Mobile Ads SDK in parallel while
    // checking for new consent information. Consent obtained in the
    // previous session can be used to request ads.
    _initializeMobileAdsSDK();
  }

  void _initializeMobileAdsSDK() async {
    if (_isMobileAdsInitializeCalled) {
      return;
    }

    // Initialize the Mobile Ads SDK if the SDK has gathered consent aligned with
    // the app's configured messages.
    var canRequestAds = await ConsentInformation.instance.canRequestAds();
    if (canRequestAds) {
      setState(() {
        _isMobileAdsInitializeCalled = true;
      });

      // Initialize the Mobile Ads SDK.
      MobileAds.instance.initialize();

      // TODO: Request an ad.
    }
  }
}

Opções de privacidade

Alguns formulários de consentimento exigem que o usuário modifique o consentimento a qualquer momento. Siga as etapas abaixo para implementar um botão de opções de privacidade, se necessário.

Para fazer isso:

1. Implemente um elemento da interface, como um botão na página de configurações do app, que acione um formulário de opções de privacidade.
2. Após a conclusão de loadAndShowConsentFormIfRequired() , confira getPrivacyOptionsRequirementStatus() para determinar se o elemento da interface que pode apresentar o formulário de opções de privacidade será mostrado ou não.
3. Quando um usuário interagir com o elemento da interface, chame showPrivacyOptionsForm() para mostrar o formulário e poder atualizar as opções de privacidade a qualquer momento.

class AppExampleState extends State<AppExample> {
  static const _privacySettingsText = 'Privacy Settings';

  // Use a bool to initialize the Mobile Ads SDK and load ads once.
  var _isMobileAdsInitializeCalled = false;

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'App Example',
      home: Scaffold(
          appBar: AppBar(
            title: const Text('App Example'),
            actions: _isMobileAdsSDKInitialized
                // Regenerate the options menu to include a privacy setting.
                ? _privacySettingsAppBarAction()
                : null
          ),
          body: // ...
      ),
    );
  }

  List<Widget> _privacySettingsAppBarAction() {
    return <Widget>[
      FutureBuilder(
          future: ConsentInformation.instance.isPrivacyOptionsRequired(),
          builder: (context, snapshot) {
            final bool visibility = snapshot.data ?? false;
            return Visibility(
                visible: visibility,
                child: PopupMenuButton<String>(
                  onSelected: (String result) {
                    if (result == _privacySettingsText) {
                      ConsentForm.showPrivacyOptionsForm((formError) {
                        if (formError != null) {
                          debugPrint(
                              "${formError.errorCode}: ${formError.message}");
                        }
                      });
                    }
                  },
                  itemBuilder: (BuildContext context) =>
                      <PopupMenuEntry<String>>[
                    const PopupMenuItem<String>(
                        value: _privacySettingsText,
                        child: Text(_privacySettingsText))
                  ],
                ));
          })
    ];
  }
}

testes

Se você quiser testar a integração no app durante o desenvolvimento, siga estas etapas para registrar o dispositivo de teste de forma programática. Remova o código que define esses IDs de dispositivo de teste antes de lançar o app.

1. Chame requestConsentInfoUpdate().

2. Verifique a saída do registro para ver uma mensagem semelhante ao exemplo a seguir, que mostra o ID do dispositivo e como adicioná-lo como dispositivo de teste:

   Android

   Use new ConsentDebugSettings.Builder().addTestDeviceHashedId("33BE2250B43518CCDA7DE426D04EE231")
   to set this as a debug device.
   

   iOS

   <UMP SDK>To enable debug mode for this device,
   set: UMPDebugSettings.testDeviceIdentifiers = @[2077ef9a63d2b398840261c8221a0c9b]
   

3. Copie o ID do dispositivo de teste para a área de transferência.

4. Modifique seu código para chamar ConsentDebugSettings.testIdentifiers e transmitir uma lista dos IDs dos dispositivos de teste.

   ConsentDebugSettings debugSettings = ConsentDebugSettings(
     testIdentifiers: ["TEST-DEVICE-HASHED-ID"],
   );
   
   ConsentRequestParameters params =
       ConsentRequestParameters(consentDebugSettings: debugSettings);
   
   ConsentInformation.instance.requestConsentInfoUpdate(params, () async {
     // ...
   };
   

Forçar uma localização geográfica

O SDK da UMP oferece uma maneira de testar o comportamento do seu app como se o dispositivo estivesse localizado no EEE ou no Reino Unido usando the DebugGeography field on ConsentDebugSettings. As configurações de depuração só funcionam em dispositivos de teste.

ConsentDebugSettings debugSettings = ConsentDebugSettings(
  debugGeography: DebugGeography.debugGeographyEea,
  testIdentifiers: ["TEST-DEVICE-HASHED-ID"],
);

ConsentRequestParameters params =
    ConsentRequestParameters(consentDebugSettings: debugSettings);

ConsentInformation.instance.requestConsentInfoUpdate(params, () async {
  // ...
};

Redefinir estado de consentimento

Ao testar seu app com o SDK da UMP, pode ser útil redefinir o estado do SDK para que você possa simular a primeira experiência de instalação de um usuário. O SDK fornece o método reset() para fazer isso.

ConsentInformation.instance.reset();

Atenção: esse método é destinado apenas para fins de teste. Não chame reset() no código de produção.