Começar

O SDK da plataforma de mensagens de usuários (UMP) do Google é uma ferramenta de privacidade e mensagens para ajudar você a gerenciar as opções de privacidade. Para mais informações, consulte Sobre a página "Privacidade e mensagens". Confira uma implementação do IMA com o SDK da UMP nos apps de exemplo Objective-C ou Swift da UMP.

Criar um tipo de mensagem

Crie mensagens do usuário com um dos tipos disponíveis na guia Privacidade e mensagens da sua conta do Ad Manager. O SDK da UMP tenta mostrar uma mensagem de privacidade criada com base no ID do aplicativo de anúncios de mídia interativa definido no seu projeto.

Para mais detalhes, consulte Sobre privacidade e mensagens.

Importar o SDK

O SDK da UMP não é incluído como uma dependência do SDK do IMA. Portanto, você precisa adicionar o SDK da UMP explicitamente.

CocoaPods (preferencial)

A maneira mais fácil de importar o SDK para um projeto do iOS é usando o CocoaPods. Abra o Podfile do projeto e adicione esta linha ao destino do app:

pod 'GoogleUserMessagingPlatform'

Em seguida, execute o comando:

pod install --repo-update

Se você não conhece o CocoaPods, consulte Como usar o CocoaPods para saber como criar e usar arquivos Pod.

Gerenciador de pacotes do Swift

O SDK da UMP também oferece suporte ao Gerenciador de pacotes do Swift. Siga estas etapas para importar o pacote Swift.

  1. No Xcode, instale o pacote Swift do SDK UMP acessando File > Add Packages….

  2. No prompt exibido, pesquise o repositório do GitHub do pacote Swift do SDK da UMP:

    https://github.com/googleads/swift-package-manager-google-user-messaging-platform.git

  3. Selecione a versão do pacote Swift do SDK UMP que você quer usar. Para novos projetos, recomendamos usar a versão principal mais recente.

O Xcode resolve as dependências do pacote e faz o download delas em segundo plano. Para mais detalhes sobre como adicionar dependências de pacote, consulte o artigo da Apple.

Adicionar o ID do aplicativo

Você encontra o ID do aplicativo na interface do Ad Manager. Adicione o ID ao Info.plist com o seguinte snippet de código:

<key>UMPApplicationIdentifier</key>
<string>ca-app-pub-xxxxxxxxxxxxxxxx~yyyyyyyyyy</string>

Para coletar o consentimento, siga estas etapas:

  1. Solicitação das informações mais recentes de consentimento do usuário.
  2. Carregue e apresente um formulário de consentimento, se necessário.

Você precisa solicitar uma atualização das informações de consentimento do usuário em cada inicialização do app usando requestConsentInfoUpdateWithParameters:completionHandler:. Essa solicitação verifica o seguinte:

  • Se o consentimento é obrigatório. Por exemplo, o consentimento é necessário pela primeira vez ou a decisão de consentimento anterior expirou.
  • Se um ponto de entrada de opções de privacidade é necessário. Algumas mensagens de privacidade exigem que os apps permitam que os usuários modifiquem as opções de privacidade a qualquer momento.

Carregar e apresentar um formulário de mensagem de privacidade, se necessário

Depois de receber o status de consentimento mais atualizado, chame loadAndPresentIfRequiredFromViewController:completionHandler: para carregar os formulários necessários para coletar o consentimento do usuário. Após o carregamento, os formulários são apresentados imediatamente.

O código abaixo demonstra como solicitar as informações de consentimento mais recentes do usuário. Se necessário, o código será carregado e apresentará um formulário de mensagem de privacidade:

Swift


// Requesting an update to consent information should be called on every app launch.
UMPConsentInformation.sharedInstance.requestConsentInfoUpdate(with: parameters) {
  requestConsentError in
  guard requestConsentError == nil else {
    return consentGatheringComplete(requestConsentError)
  }

  UMPConsentForm.loadAndPresentIfRequired(from: consentFormPresentationviewController) {
    loadAndPresentError in

    // Consent has been gathered.
    consentGatheringComplete(loadAndPresentError)
  }
}
ConsentManager.swift

Objective-C


// Requesting an update to consent information should be called on every app launch.
[UMPConsentInformation.sharedInstance
    requestConsentInfoUpdateWithParameters:parameters
                         completionHandler:^(NSError *_Nullable requestConsentError) {
                           if (requestConsentError) {
                             consentGatheringComplete(requestConsentError);
                           } else {
                             [UMPConsentForm
                                 loadAndPresentIfRequiredFromViewController:viewController
                                                          completionHandler:^(
                                                              NSError
                                                                  *_Nullable loadAndPresentError) {
                                                            // Consent has been gathered.
                                                            consentGatheringComplete(
                                                                loadAndPresentError);
                                                          }];
                           }
                         }];
ConsentManager.m

Opções de privacidade

Alguns formulários de mensagem de privacidade são apresentados em um ponto de entrada de opções de privacidade renderizado pelo editor, permitindo que os usuários gerenciem as opções de privacidade a qualquer momento. Para saber mais sobre qual mensagem é exibida aos seus usuários no ponto de entrada das opções de privacidade, consulte Tipos de mensagens do usuário disponíveis.

Verificar se um ponto de entrada de opções de privacidade é necessário

Depois de chamar requestConsentInfoUpdateWithParameters:completionHandler:, verifique UMPConsentInformation.sharedInstance.privacyOptionsRequirementStatus para determinar se um ponto de entrada de opções de privacidade é necessário para o app:

Swift


var isPrivacyOptionsRequired: Bool {
  return UMPConsentInformation.sharedInstance.privacyOptionsRequirementStatus == .required
}
ConsentManager.swift

Objective-C


- (BOOL)areGDPRConsentMessagesRequired {
  return UMPConsentInformation.sharedInstance.privacyOptionsRequirementStatus ==
         UMPPrivacyOptionsRequirementStatusRequired;
}
ConsentManager.m

Adicionar um elemento visível ao app

Se um ponto de entrada de privacidade for necessário, adicione um elemento de interface visível e interativo ao app que apresente o formulário de opções de privacidade. Se um ponto de entrada de privacidade não for necessário, configure o elemento da interface para que ele não seja visível nem interativo.

Swift


self.privacySettingsButton.isEnabled = ConsentManager.shared.isPrivacyOptionsRequired
ViewController.swift

Objective-C


// Set up the privacy options button to show the UMP privacy form.
// Check ConsentInformation.getPrivacyOptionsRequirementStatus
// to see the button should be shown or hidden.
strongSelf.privacySettingsButton.hidden =
    !ConsentManager.sharedInstance.areGDPRConsentMessagesRequired;
ViewController.m

Apresentar o formulário de opções de privacidade

Quando o usuário interagir com o elemento, apresente o formulário de opções de privacidade:

Swift


UMPConsentForm.presentPrivacyOptionsForm(
  from: viewController, completionHandler: completionHandler)
ConsentManager.swift

Objective-C


[UMPConsentForm presentPrivacyOptionsFormFromViewController:viewController
                                          completionHandler:completionHandler];
ConsentManager.m

Solicitar anúncios

Antes de solicitar anúncios no seu app, verifique se você recebeu o consentimento do usuário usando UMPConsentInformation.sharedInstance.canRequestAds. Há dois lugares para verificar ao coletar o consentimento:

  • Depois que o consentimento foi coletado na sessão atual.
  • Imediatamente após chamar requestConsentInfoUpdateWithParameters:completionHandler:. É possível que o consentimento tenha sido concedido na sessão anterior. Como prática recomendada de latência, recomendamos não esperar a conclusão do callback para que você possa começar a carregar anúncios assim que possível após o lançamento do app.

Se ocorrer um erro durante o processo de coleta de consentimento, ainda será necessário verificar se você pode solicitar anúncios. O SDK do UMP usa o status de consentimento da sessão anterior.

O código a seguir verifica se você pode solicitar anúncios durante o processo de coleta de consentimento:

Swift


ConsentManager.shared.gatherConsent(from: self) { [weak self] consentError in
  guard let self else { return }

  if let consentError {
    // Consent gathering failed. This sample loads ads using
    // consent obtained in the previous session.
    print("Error: \(consentError.localizedDescription)")
  }
  // ...
}
ViewController.swift

Objective-C


  [ConsentManager.sharedInstance
      gatherConsentFromConsentPresentationViewController:self
                                consentGatheringComplete:^(NSError *_Nullable consentError) {
                                  if (consentError) {
                                    // Consent gathering failed.
                                    NSLog(@"Error: %@", consentError.localizedDescription);
                                  }

                                  __strong __typeof__(self) strongSelf = weakSelf;
                                  if (!strongSelf) {
                                    return;
                                  }

                                  // ...

                                  if (ConsentManager.sharedInstance.canRequestAds) {
                                    [strongSelf setupAdsLoader];
                                  }
                                }];

  // This sample attempts to load ads using consent obtained in the previous session.
  if (ConsentManager.sharedInstance.canRequestAds) {
    [self setupAdsLoader];
  }

  [self setUpContentPlayer];
}

- (IBAction)onPlayButtonTouch:(id)sender {
  [self requestAds];
  self.playButton.hidden = YES;
}

#pragma mark Content Player Setup

- (void)setUpContentPlayer {
  // Load AVPlayer with path to our content.
  NSURL *contentURL = [NSURL URLWithString:kTestAppContentUrl_MP4];
  self.contentPlayer = [AVPlayer playerWithURL:contentURL];

  // Create a player layer for the player.
  AVPlayerLayer *playerLayer = [AVPlayerLayer playerLayerWithPlayer:self.contentPlayer];

  // Size, position, and display the AVPlayer.
  playerLayer.frame = self.videoView.layer.bounds;
  [self.videoView.layer addSublayer:playerLayer];

  // Set up our content playhead and contentComplete callback.
  self.contentPlayhead = [[IMAAVPlayerContentPlayhead alloc] initWithAVPlayer:self.contentPlayer];
  [[NSNotificationCenter defaultCenter] addObserver:self
                                           selector:@selector(contentDidFinishPlaying:)
                                               name:AVPlayerItemDidPlayToEndTimeNotification
                                             object:self.contentPlayer.currentItem];
}

#pragma mark SDK Setup

- (void)setupAdsLoader {
  self.adsLoader = [[IMAAdsLoader alloc] initWithSettings:nil];
  self.adsLoader.delegate = self;
}

- (void)requestAds {
  // Create an ad display container for ad rendering.
  IMAAdDisplayContainer *adDisplayContainer =
      [[IMAAdDisplayContainer alloc] initWithAdContainer:self.videoView
                                          viewController:self
                                          companionSlots:nil];
  // Create an ad request with our ad tag, display container, and optional user context.
  IMAAdsRequest *request = [[IMAAdsRequest alloc] initWithAdTagUrl:kTestAppAdTagUrl
                                                adDisplayContainer:adDisplayContainer
                                                   contentPlayhead:self.contentPlayhead
                                                       userContext:nil];
  [self.adsLoader requestAdsWithRequest:request];
}

- (void)contentDidFinishPlaying:(NSNotification *)notification {
  // Make sure we don't call contentComplete as a result of an ad completing.
  if (notification.object == self.contentPlayer.currentItem) {
    [self.adsLoader contentComplete];
  }
}

#pragma mark AdsLoader Delegates

- (void)adsLoader:(IMAAdsLoader *)loader adsLoadedWithData:(IMAAdsLoadedData *)adsLoadedData {
  // Grab the instance of the IMAAdsManager and set ourselves as the delegate.
  self.adsManager = adsLoadedData.adsManager;
  self.adsManager.delegate = self;
  // Create ads rendering settings to tell the SDK to use the in-app browser.
  IMAAdsRenderingSettings *adsRenderingSettings = [[IMAAdsRenderingSettings alloc] init];
  adsRenderingSettings.linkOpenerPresentingController = self;
  // Initialize the ads manager.
  [self.adsManager initializeWithAdsRenderingSettings:adsRenderingSettings];
}

- (void)adsLoader:(IMAAdsLoader *)loader failedWithErrorData:(IMAAdLoadingErrorData *)adErrorData {
  // Something went wrong loading ads. Log the error and play the content.
  NSLog(@"Error loading ads: %@", adErrorData.adError.message);
  [self.contentPlayer play];
}

#pragma mark AdsManager Delegates

- (void)adsManager:(IMAAdsManager *)adsManager didReceiveAdEvent:(IMAAdEvent *)event {
  // When the SDK notified us that ads have been loaded, play them.
  if (event.type == kIMAAdEvent_LOADED) {
    [adsManager start];
  }
}

- (void)adsManager:(IMAAdsManager *)adsManager didReceiveAdError:(IMAAdError *)error {
  // Something went wrong with the ads manager after ads were loaded. Log the error and play the
  // content.
  NSLog(@"AdsManager error: %@", error.message);
  [self.contentPlayer play];
}

- (void)adsManagerDidRequestContentPause:(IMAAdsManager *)adsManager {
  // The SDK is going to play ads, so pause the content.
  [self.contentPlayer pause];
}

- (void)adsManagerDidRequestContentResume:(IMAAdsManager *)adsManager {
  // The SDK is done playing ads (at least for now), so resume the content.
  [self.contentPlayer play];
}

@end

ViewController.m

O código abaixo configura o SDK do Interactive Media Ads depois que o consentimento do usuário é coletado:

Swift


private func requestAds() {
  // Create ad display container for ad rendering.
  let adDisplayContainer = IMAAdDisplayContainer(
    adContainer: videoView, viewController: self, companionSlots: nil)
  // Create an ad request with our ad tag, display container, and optional user context.
  let request = IMAAdsRequest(
    adTagUrl: ViewController.testAppAdTagURL,
    adDisplayContainer: adDisplayContainer,
    contentPlayhead: contentPlayhead,
    userContext: nil)

  adsLoader.requestAds(with: request)
}
ViewController.swift

Objective-C


- (void)setupAdsLoader {
  self.adsLoader = [[IMAAdsLoader alloc] initWithSettings:nil];
  self.adsLoader.delegate = self;
}
ViewController.m

Teste

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

  1. Ligue para a requestConsentInfoUpdateWithParameters:completionHandler:.

  2. Verifique se há uma mensagem semelhante ao exemplo abaixo na saída do registro, que mostra o ID do dispositivo e como adicioná-lo como um dispositivo de teste:

    <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 o código para chamar UMPDebugSettings().testDeviceIdentifiers e transmitir uma lista dos IDs dos dispositivos de teste.

    Swift

    let parameters = UMPRequestParameters()
let debugSettings = UMPDebugSettings()

debugSettings.testDeviceIdentifiers = ["TEST-DEVICE-HASHED-ID"]
parameters.debugSettings = debugSettings

// Include the UMPRequestParameters in your consent request.
UMPConsentInformation.sharedInstance.requestConsentInfoUpdate(
    with: parameters,
    completionHandler: { error in
      // ...
    })

    Objective-C

    UMPRequestParameters *parameters = [[UMPRequestParameters alloc] init];
UMPDebugSettings *debugSettings = [[UMPDebugSettings alloc] init];

debugSettings.testDeviceIdentifiers = @[ @"TEST-DEVICE-HASHED-ID" ];
parameters.debugSettings = debugSettings;

// Include the UMPRequestParameters in your consent request.
[UMPConsentInformation.sharedInstance
    requestConsentInfoUpdateWithParameters:parameters
                        completionHandler:^(NSError *_Nullable error){
                          // ...
}];

Forçar uma região geográfica

O SDK da UMP oferece uma maneira de testar o comportamento do app como se o dispositivo estivesse localizado em várias regiões, como o EEE ou o Reino Unido, usando UMPDebugGeography. As configurações de depuração só funcionam em dispositivos de teste.

Swift

let parameters = UMPRequestParameters()
let debugSettings = UMPDebugSettings()

debugSettings.testDeviceIdentifiers = ["TEST-DEVICE-HASHED-ID"]
debugSettings.geography = .EEA
parameters.debugSettings = debugSettings

// Include the UMPRequestParameters in your consent request.
UMPConsentInformation.sharedInstance.requestConsentInfoUpdate(
    with: parameters,
    completionHandler: { error in
      // ...
    })

Objective-C

UMPRequestParameters *parameters = [[UMPRequestParameters alloc] init];
UMPDebugSettings *debugSettings = [[UMPDebugSettings alloc] init];

debugSettings.testDeviceIdentifiers = @[ @"TEST-DEVICE-HASHED-ID" ];
debugSettings.geography = UMPDebugGeographyEEA;
parameters.debugSettings = debugSettings;

// Include the UMPRequestParameters in your consent request.
[UMPConsentInformation.sharedInstance
    requestConsentInfoUpdateWithParameters:parameters
                         completionHandler:^(NSError *_Nullable error){
                           // ...
}];

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

Swift

UMPConsentInformation.sharedInstance.reset()

Objective-C

[UMPConsentInformation.sharedInstance reset];

Exemplos no GitHub

Confira um exemplo completo da integração do SDK do UMP abordada nesta página em Swift UmpExample e Objective-C UmpExample.

Próxima
Consentimento da UE e GDPR