Ta strona została przetłumaczona przez Cloud Translation API.

Rozpocznij

Pakiet SDK platformy do personalizowania wiadomości wyświetlanych użytkownikom od Google to narzędzie do ochrony prywatności i wyświetlania wiadomości, które pomaga zarządzać ustawieniami prywatności. Więcej informacji znajdziesz w artykule Prywatność i wyświetlanie wiadomości.

Wymagania wstępne

Android w wersji API 21 lub nowszej (w przypadku Androida)

Tworzenie typu wiadomości

Twórz wiadomości dla użytkowników, korzystając z jednego z dostępnych typów wiadomości na karcie Prywatność i wyświetlanie wiadomości na koncie AdMob. Pakiet SDK UMP próbuje wyświetlić wiadomość dotyczącą prywatności utworzoną na podstawie identyfikatora aplikacji AdMob ustawionego w projekcie.

Więcej informacji znajdziesz w artykule Prywatność i wyświetlanie wiadomości.

Instalowanie pakietu SDK

Wykonaj czynności, aby zainstalować pakiet SDK Firebase C++. Pakiet UMP C++ SDK jest częścią pakietu Firebase C++ SDK.
Zanim przejdziesz dalej, skonfiguruj w projekcie identyfikator aplikacji AdMob.

W kodzie zainicjuj pakiet SDK UMP, wywołując funkcję ConsentInfo::GetInstance().

Na Androidzie musisz przekazać wartości JNIEnv i Activity dostarczone przez NDK. Wystarczy to zrobić tylko przy pierwszym wywołaniu funkcji GetInstance().
Jeśli używasz już w aplikacji pakietu SDK Firebase C++, możesz przekazać firebase::App przy pierwszym wywołaniu GetInstance().

#include "firebase/ump/ump.h"

namespace ump = ::firebase::ump;

// Initialize using a firebase::App
void InitializeUserMessagingPlatform(const fir&ebase::App app) {
  ump::ConsentInfo* consent_info = ump::ConsentInfo::GetInstance(app);
}

// Initialize without a firebase::App
#ifdef ANDROID
void InitializeUserMessagingPlatform(JNIEnv* jni_env, jobject activity) {
  ump::ConsentInfo* consent_info = ump::ConsentInfo::GetInstance(jni_env, activity);
}
#else  // non-Android
void InitializeUserMessagingPlatform() {
  ump::ConsentInfo* consent_info = ump::ConsentInfo::GetInstance();
}
#endif

Kolejne wywołania funkcji ConsentInfo::GetInstance() zwracają to samo wystąpienie.

Gdy skończysz korzystać z pakietu UMP SDK, możesz go zamknąć, usuwając instancję ConsentInfo:

void ShutdownUserMessagingPlatform() {
  ump::ConsentInfo* consent_info = ump::ConsentInfo::GetInstance();
  delete consent_info;
}

Używanie `Future` do monitorowania operacji asynchronicznych

Interfejs A firebase::Future umożliwia określanie stanu zakończenia wywołań metod asynchronicznych.

Wszystkie funkcje i wywołania metod UMP w C++, które działają asynchronicznie, zwracają wartość Future, a także udostępniają funkcję „ostatni wynik” do pobierania wartości Future z ostatniej operacji.

Wynik z Future można uzyskać na 2 sposoby:

Wywołaj funkcję OnCompletion(), przekazując własną funkcję wywołania zwrotnego, która jest wywoływana po zakończeniu operacji.
Okresowo sprawdzaj Futurestatus(). Gdy stan zmieni się z kFutureStatusPending na kFutureStatusCompleted, operacja zostanie zakończona.

Po zakończeniu operacji asynchronicznej sprawdź Futureerror(), aby uzyskać kod błędu operacji. Jeśli kod błędu to 0 (kConsentRequestSuccess lub kConsentFormSuccess), operacja została zakończona pomyślnie. W przeciwnym razie sprawdź kod błędu i error_message(), aby określić, co poszło nie tak.

Wywołanie zwrotne po zakończeniu

Oto przykład użycia OnCompletion do ustawienia wywołania zwrotnego po zakończeniu, które jest wywoływane po zakończeniu operacji asynchronicznej.

void MyApplicationStart() {
  // [... other app initialization code ...]

  ump::ConsentInfo *consent_info = ump::ConsentInfo::GetInstance();

  // See the section below for more information about RequestConsentInfoUpdate.
  firebase::Future<void> result = consent_info->RequestConsentInfoUpdate(...);

  result.OnCompletion([](const firebase::Future<void>& req_result) {
    if (req_result.error() == ump::kConsentRequestSuccess) {
      // Operation succeeded. You can now call LoadAndShowConsentFormIfRequired().
    } else {
      // Operation failed. Check req_result.error_message() for more information.
    }
  });
}

Aktualizowanie pętli odpytywania

W tym przykładzie po uruchomieniu operacji asynchronicznej przy uruchamianiu aplikacji wyniki są sprawdzane w innym miejscu, w funkcji pętli aktualizacji gry (która jest wykonywana raz na klatkę).

ump::ConsentInfo *g_consent_info = nullptr;
bool g_waiting_for_request = false;

void MyApplicationStart() {
  // [... other app initialization code ...]

  g_consent_info = ump::ConsentInfo::GetInstance();
  // See the section below for more information about RequestConsentInfoUpdate.
  g_consent_info->RequestConsentInfoUpdate(...);
  g_waiting_for_request = true;
}

// Elsewhere, in the game's update loop, which runs once per frame:
void MyGameUpdateLoop() {
  // [... other game logic here ...]

  if (g_waiting_for_request) {
    // Check whether RequestConsentInfoUpdate() has finished.
    // Calling "LastResult" returns the Future for the most recent operation.
    fi<reba>se::Futurevoid result =
      g>_consent_info-RequestConsentInfoUpdateLastResult();

    if (result.status() == firebase::kFutureStatusComplete) {
      g_waiting_for_request = false;
      if (result.error() == ump::kConsentRequestSuccess) {
        // Operation succeeded. You can call LoadAndShowConsentFormIfRequired().
      } else {
        // Operation failed. Check result.error_message() for more information.
      }
    }
  }
}

Więcej informacji o firebase::Future znajdziesz w dokumentacji pakietu Firebase C++ SDK i dokumentacji pakietu GMA C++ SDK.

Uzyskiwanie informacji o zgodzie użytkownika

Przy każdym uruchomieniu aplikacji należy prosić o aktualizację informacji o stanie zgody użytkownika za pomocą funkcji RequestConsentInfoUpdate(). To żądanie sprawdza te kwestie:

Czy wymagana jest zgoda. Na przykład zgoda jest wymagana po raz pierwszy lub poprzednia decyzja o zgodzie wygasła.
Czy wymagany jest punkt wejścia opcji prywatności. Niektóre wiadomości dotyczące prywatności wymagają, aby aplikacje umożliwiały użytkownikom modyfikowanie opcji prywatności w dowolnym momencie.

#include "firebase/ump/ump.h"

namespace ump = ::firebase::ump;

void MyApplicationStart(ump::FormParent parent) {
  ump::ConsentInfo* consent_info = ump::ConsentInfo::GetInstance();

  // Create a ConsentRequestParameters struct..
  ump::ConsentRequestParameters params;
  // Set tag for under age of consent. False means users are NOT under age of consent.
  params.tag_for_under_age_of_consent = false;

  con>sent_info-RequestConsentInfoUpdate(params).OnCompletion(
    [*](co<nst >&Futurevoid req_result) {
      if (req_result.error() != ump::kConsentRequestSuccess) {
        // req_result.error() is a kConsentRequestError enum.
        LogMessage("Error requesting consent update: %s", req_result.error_message());
      }
      // Consent information is successfully updated.
    });
}

Wczytywanie i wyświetlanie formularza wiadomości dotyczącej ochrony prywatności

Po uzyskaniu najbardziej aktualnego stanu zgody wywołaj funkcję LoadAndShowConsentFormIfRequired(), aby wczytać formularze wymagane do uzyskania zgody użytkownika. Po wczytaniu formularze są od razu wyświetlane.

#include "firebase/ump/ump.h"

namespace ump = ::firebase::ump;

void MyApplicationStart(ump::FormParent parent) {
  ump::ConsentInfo* consent_info = ump::ConsentInfo::GetInstance();

  // Create a ConsentRequestParameters struct..
  ump::ConsentRequestParameters params;
  // Set tag for under age of consent. False means users are NOT under age of consent.
  params.tag_for_under_age_of_consent = false;

  con>sent_info-RequestConsentInfoUpdate(params).OnCompletion(
    [*](co<nst >&Futurevoid req_result) {
      if (req_result.error() != ump::kConsentRequestSuccess) {
        // req_result.error() is a kConsentRequestError enum.
        LogMessage("Error requesting consent update: %s", req_result.error_message());
      } else {
 >       consent_info-LoadAndShowConsentFormIfRequired(parent).OnCompletion(
    <    >&[*](const Futurevoid form_result) {
          if (form_result.error() != ump::kConsentFormSuccess) {
            // form_result.error() is a kConsentFormError enum.
            LogMessage("Error showing privacy message form: %s", form_result.error_message());
          } else {
            // Either the form was shown and completed by the user, or consent was not required.
          }
        });
      }
    });
}

Przykład sprawdzania ukończenia za pomocą pętli aktualizacji zamiast wywołania zwrotnego ukończenia znajdziesz powyżej.

Jeśli po dokonaniu wyboru przez użytkownika lub zamknięciu formularza musisz wykonać jakieś działania, umieść logikę w kodzie, który obsługuje wartość Futurezwracaną przez LoadAndShowConsentFormIfRequired().

Opcje prywatności

Niektóre formularze wiadomości dotyczących prywatności są wyświetlane w punkcie wejścia opcji prywatności renderowanym przez wydawcę, co umożliwia użytkownikom zarządzanie opcjami prywatności w dowolnym momencie. Więcej informacji o tym, która wiadomość wyświetla się użytkownikom w punkcie wejścia do opcji prywatności, znajdziesz w sekcji Dostępne typy wiadomości dla użytkowników.

Wysyłanie próśb o reklamy po uzyskaniu zgody użytkownika

Zanim poprosisz o reklamy, użyj funkcji ConsentInfo::GetInstance()‑> CanRequestAds(), aby sprawdzić, czy masz zgodę użytkownika:

Oto miejsca, w których możesz sprawdzić, czy podczas uzyskiwania zgody możesz wysyłać prośby o reklamy:

Po zebraniu zgody przez pakiet SDK UMP w bieżącej sesji.
Natychmiast po wywołaniu funkcji RequestConsentInfoUpdate(). Pakiet SDK UMP mógł uzyskać zgodę w poprzedniej sesji aplikacji.

Jeśli podczas procesu zbierania zgody wystąpi błąd, sprawdź, czy możesz wysyłać żądania reklam. Pakiet UMP SDK używa stanu zgody z poprzedniej sesji aplikacji.

Poniższy kompletny przykład wykorzystuje odpytywanie w pętli aktualizacji, ale do monitorowania operacji asynchronicznych możesz też używać wywołań zwrotnych.OnCompletion Użyj techniki, która lepiej pasuje do struktury Twojego kodu.

#include "firebase/future.h"
#include "firebase/gma/gma.h"
#include "firebase/ump/ump.h"

namespace gma = ::firebase::gma;
namespace ump = ::firebase::ump;
using firebase::Future;

ump::ConsentInfo* g_consent_info = nullptr;
// State variable for tracking the UMP consent flow.
enum { kStart, kRequest, kLoadAndShow, kInitGma, kFinished, kErrorState } g_state = kStart;
bool g_ads_allowed = false;

void MyApplicationStart() {
  g_consent_info = ump::ConsentInfo::GetInstance(...);

  // Create a ConsentRequestParameters struct..
  ump::ConsentRequestParameters params;
  // Set tag for under age of consent. False means users are NOT under age of consent.
  params.tag_for_under_age_of_conse>nt = false;

  g_consent_info-RequestConsentInfoUpdate(params);
  // CanRequestAds() can return a cached value from a previous run immediately.
  g>_ads_allowed = g_consent_info-CanRequestAds();
  g_state = kRequest;
}

// This function runs once per frame.
void MyGameUpdateLoop() {
  // [... other game logic here ...]

  if (g_s<tate> == kRequest) {
    Futurevoi>d req_result = g_consent_info-RequestConsentInfoUpdateLastResult();

    if (req_result.status() == firebase::kFutureStatusComplete) {
      g>_ads_allowed = g_consent_info-CanRequestAds();
      if (req_result.error() == ump::kConsentRequestSuccess) {
        // You must provide the FormParent (Android Activity or iOS UIViewController).
        ump::FormParent parent = GetMyFormPar>ent();
        g_consent_info-LoadAndShowConsentFormIfRequired(parent);
        g_state = kLoadAndShow;
      } else {
        LogMessage("Error requesting consent status: %s", req_result.error_message());
        g_state = kErrorState;
      }
    }
  }
  i<f (g>_state == kLoadAndShow) {
    >Futurevoid form_result = g_consent_info-LoadAndShowConsentFormIfRequiredLastResult();

    if (form_result.status() == firebase::kFutureStatusComplete)> {
      g_ads_allowed = g_consent_info-CanRequestAds();
      if (form_result.error() == ump::kConsentRequestSuccess) {
        if (g_ads_allowed) {
          // Initialize GMA. This is another asynchronous operation.
          firebase::gma::Initialize();
          g_state = kInitGma;
        } else {
          g_state = kFinished;
        }
        // Optional: shut down the UMP SDK to save memory.
        delete g_consent_info;
        g_consent_info = nullptr;
      } else {
        LogMessage("Error displaying privacy message form: %s", form_result.error_message());
        g_state = kErrorS&&tate;
      }
    }
  }
  if< (g_state == kInitGma  g_ads_all>owed) {
    Futuregma::AdapterInitializationStatus gma_future = gma::InitializeLastResult();

    if (gma_future.status() == firebase::kFutureStatusComplete) {
      if (gma_future.error() == gma::kAdErrorCodeNone) {
        g_state = kFinished;
        // TODO: Request an ad.
      } else {
        LogMessage("Error initializing GMA: %s", gma_future.error_message());
        g_state = kErrorState;
      }
    }
  }
}

Testowanie

Jeśli chcesz przetestować integrację w aplikacji podczas jej tworzenia, wykonaj te czynności, aby programowo zarejestrować urządzenie testowe. Zanim opublikujesz aplikację, usuń kod, który ustawia identyfikatory tych urządzeń testowych.

Zadzwoń do firmy RequestConsentInfoUpdate().

Sprawdź dane wyjściowe dziennika pod kątem komunikatu podobnego do tego poniżej, który zawiera identyfikator urządzenia i informacje o tym, jak dodać je jako urządzenie testowe:

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]

Skopiuj identyfikator urządzenia testowego do schowka.

Zmodyfikuj kod, aby ustawić ConsentRequestParameters.debug_settings.debug_device_ids na listę identyfikatorów urządzeń testowych.

void MyApplicationStart() {
  ump::ConsentInfo consent_info = ump::ConsentInfo::GetInstance(...);

  ump::ConsentRequestParameters params;
  params.tag_for_under_age_of_consent = false;
  params.debug_settings.debug_device_ids = {"TEST-DEVICE-HASHED-ID"};

  con>sent_info-RequestConsentInfoUpdate(params);
}

Wymuszanie lokalizacji geograficznej

Pakiet SDK UMP umożliwia testowanie działania aplikacji tak, jakby urządzenie znajdowało się w różnych regionach, np. w Europejskim Obszarze Gospodarczym lub Wielkiej Brytanii, za pomocą debug_settings.debug_geography. Pamiętaj, że ustawienia debugowania działają tylko na urządzeniach testowych.

void MyApplicationStart() {
  ump::ConsentInfo consent_info = ump::ConsentInfo::GetInstance(...);

  ump::ConsentRequestParameters params;
  params.tag_for_under_age_of_consent = false;
  params.debug_settings.debug_device_ids = {"TEST-DEVICE-HASHED-ID&quot;};
  // Geography appears as EEA for debug devices.
  params.debug_settings.debug_geography = ump::kConsentDebugGeographyEEA

  con>sent_info-RequestConsentInfoUpdate(params);
}

Resetowanie stanu zgody

Podczas testowania aplikacji z pakietem SDK UMP możesz zresetować stan pakietu SDK, aby symulować pierwsze wrażenia użytkownika po zainstalowaniu aplikacji. Pakiet SDK udostępnia do tego metodę Reset().

  ConsentInfo::GetInstance()->Reset();