इस पेज का अनुवाद Cloud Translation API से किया गया है.

शुरू करें

Google ईयू उपयोगकर्ता की सहमति के तहत नीति है, तो आपको सभी ज़रूरी शर्तें पूरी करनी होंगी यूरोपियन इकनॉमिक एरिया (ईईए) में रहने वाले अपने उपयोगकर्ताओं को कुछ जानकारी देना और कुकी या अन्य लोकल स्टोरेज का इस्तेमाल करने के लिए उनकी सहमति लें. साथ ही, विज्ञापन दिखाने के लिए निजी डेटा (जैसे कि AdID) का इस्तेमाल करना होगा. यह नीति ईयू (यूरोपीय संघ) के ई-निजता निर्देश और जनरल डेटा प्रोटेक्शन रेगुलेशन (जीडीपीआर).

Google, पब्लिशर को इस नीति के तहत अपनी ज़िम्मेदारी पूरी करने के लिए User Messaging Platform (UMP) SDK टूल का इस्तेमाल करना होगा. UMP SDK को सहायता केंद्र में अपडेट कर दिया गया है IAB के नए स्टैंडर्ड के बारे में बताया गया है. ये सभी कॉन्फ़िगरेशन अब आसानी से निजता और AdMob सुरक्षा सुविधा के तहत मैनेज किया जाता है को बढ़ावा देते हैं.

ज़रूरी शर्तें

शुरुआती निर्देश के बारे में पूरी जानकारी दें

Android का एपीआई लेवल 21 या उसके बाद का वर्शन (Android के लिए)

अगर आप जीडीपीआर से जुड़ी ज़रूरी शर्तों पर काम कर रहे हैं, तो पढ़ें IAB की ज़रूरी शर्तें यूरोपीय संघ पर कैसे असर डालती हैं सहमति जताने वाले मैसेज

मैसेज का टाइप बनाएं

इनमें से किसी एक विकल्प का इस्तेमाल करके, उपयोगकर्ता मैसेज बनाना उपयोगकर्ता के लिए उपलब्ध मैसेज टाइप निजता और मैसेज सेवा टैब में AdMob जोड़ें. UMP SDK टूल की मदद से, ऐप्लिकेशन आईडी AdMob से बनाया गया उपयोगकर्ता मैसेज अपने प्रोजेक्ट में जोड़ा जा सकता है. अगर आपके ऐप्लिकेशन के लिए कोई मैसेज कॉन्फ़िगर नहीं किया गया है, तो कोई गड़बड़ी दिखाता है.

ज़्यादा जानकारी के लिए, यह देखें निजता और मैसेज सेवा के बारे में जानकारी.

SDK टूल इंस्टॉल करें

Google Mobile Ads (GMA) C++ इंस्टॉल करने के लिए, यह तरीका अपनाएं SDK टूल. UMP C++ SDK टूल, GMA C++ SDK टूल में शामिल है.
पक्का करें कि आपने अपने ऐप्लिकेशन के AdMob ऐप्लिकेशन को कॉन्फ़िगर किया हो प्रोजेक्ट में मौजूद आईडी जारी रखने से पहले.
अपने कोड में, UMP SDK को कॉल करके शुरू करें ConsentInfo::GetInstance().
- Android पर, आपको इसके द्वारा उपलब्ध कराए गए JNIEnv और Activity में पास करना होगा एनडीके. आपको GetInstance() को पहली बार कॉल करने पर ही ऐसा करना होगा.
- इसके अलावा, अगर पहले से ही Firebase C++ SDK टूल का इस्तेमाल करके, तो firebase::App में पहली बार GetInstance() को कॉल करने पर.
```
#include "firebase/gma/ump.h"

namespace ump = ::firebase::gma::ump;

// Initialize using a firebase::App
void InitializeUserMessagingPlatform(const firebase::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
```

ConsentInfo::GetInstance() को बाद में किए जाने वाले कॉल, एक ही इंस्टेंस दिखाते हैं.

ध्यान दें: GetInstance() तरीकों में विकल्प के तौर पर, firebase::InitResult आउटपुट पैरामीटर, जो नतीजे के तौर पर firebase::kInitResultSuccess दिखाता है कि SDK टूल सफलतापूर्वक शुरू किया गया या firebase::kInitResultFailedMissingDependency अगर आपके ऐप्लिकेशन में सभी ज़रूरी डिपेंडेंसी मौजूद नहीं हैं. पक्का करें कि इंस्टॉल करने के सभी चरण पूरे किए चरणों का पालन करने के लिए प्लैटफ़ॉर्म चुनें.

अगर आपने UMP SDK का इस्तेमाल कर लिया है, तो SDK टूल को बंद करने के लिए ConsentInfo इंस्टेंस:

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

एसिंक्रोनस कार्रवाइयों को मॉनिटर करने के लिए `Future` का इस्तेमाल करें

ऐप्लिकेशन firebase::Future इसमें आपको एसिंक्रोनस तरीके की पूरी होने की स्थिति पता करने का तरीका मिलता है कॉल.

एसिंक्रोनस रूप से ऑपरेट होने वाले सभी UMP C++ फ़ंक्शन और मेथड कॉल Future और "पिछला नतीजा" भी दें Future को पाने के लिए फ़ंक्शन सबसे हाल की कार्रवाई से.

Future से नतीजा पाने के दो तरीके हैं:

OnCompletion() पर कॉल करें, अपने कॉलबैक फ़ंक्शन में पास करना, जिसे ऑपरेशन के समय कॉल किया जाता है पूरा करता है.
समय-समय पर Future की status() देखते रहें. जब स्थिति kFutureStatusPending से kFutureStatusCompleted में बदल जाता है, तो कार्रवाई पूरी हो गई.

एसिंक्रोनस कार्रवाई पूरी होने के बाद, आपको कार्रवाई की गड़बड़ी का पता लगाने के लिए, Future का error() कोड. अगर गड़बड़ी का कोड 0 (kConsentRequestSuccess) है या kConsentFormSuccess), प्रक्रिया सफलतापूर्वक पूरी हो गई हो; अगर ऐसा नहीं है, तो गड़बड़ी कोड की जांच करें और गड़बड़ी का पता लगाने के लिए error_message().

पूरा होने का कॉलबैक

पूरा कॉलबैक सेट करने के लिए, OnCompletion इस्तेमाल करने का तरीका यहां दिया गया है, जिसे एसिंक्रोनस कार्रवाई पूरी होने पर कॉल किया जाता है.

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.
    }
  });
}

लूप पोलिंग अपडेट करें

इस उदाहरण में, ऐप्लिकेशन के लॉन्च के समय एसिंक्रोनस कार्रवाई शुरू होने के बाद, गेम के अपडेट लूप फ़ंक्शन (जो ब्राउज़र में खुलेगा) में एक फ़्रेम में एक बार).

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.
    firebase::Future<void> 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.
      }
    }
  }
}

firebase::Future के बारे में ज़्यादा जानकारी के लिए, Firebase C++ SDK टूल देखें दस्तावेज़ और GMA C++ SDK टूल का दस्तावेज़ पढ़ें.

ऐप्लिकेशन आईडी जोड़ें

आप यहां अपना ऐप्लिकेशन आईडी देख सकते हैं: AdMob का यूज़र इंटरफ़ेस (यूआई). आईडी को अपने के लिए यहां दिए गए कोड स्निपेट का इस्तेमाल करें:

आपको हर ऐप्लिकेशन में, उपयोगकर्ता की सहमति से जुड़ी जानकारी अपडेट करने का अनुरोध करना चाहिए RequestConsentInfoUpdate()का इस्तेमाल करके लॉन्च किया गया. इससे तय होता है कि अगर आपके उपयोगकर्ता ने अब तक सहमति नहीं दी है, तो उसे स्वीकार करने की ज़रूरत है या अगर उसकी सहमति खत्म हो गई है.

#include "firebase/gma/ump.h"

namespace ump = ::firebase::gma::ump;

void MyApplicationStart() {
  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;

  consent_info->RequestConsentInfoUpdate(params).OnCompletion(
    [](const Future<void>& result) {
      if (result.error() != ump::kConsentRequestSuccess) {
        LogMessage("Error requesting consent update: %s", result.error_message());
      } else {
        // Consent status is now available.
      }
    });
}

पूरा होने की जांच करने का उदाहरण देखने के लिए ऊपर देखें. इसके लिए, नीचे दिए गए लिंक का इस्तेमाल करें पूरी होने के कॉलबैक के बजाय लूप पोलिंग को अपडेट करें.

अगर ज़रूरी हो, तो सहमति फ़ॉर्म लोड करें और दिखाएं

सहमति की अप-टू-डेट स्थिति मिलने के बाद, LoadAndShowConsentFormIfRequired() ConsentInfo क्लास का इस्तेमाल करें. अगर सहमति की स्थिति डालना ज़रूरी है. SDK टूल एक फ़ॉर्म लोड करके उसे तुरंत दिखाता है दिए गए लक्ष्य से FormParent. Future पूरा हो गया है कॉल किया जाता है. अगर सहमति ज़रूरी नहीं है, तो Future पूरा हो गया है तुरंत कॉल किया जाएगा.

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;

  consent_info->RequestConsentInfoUpdate(params).OnCompletion(
    [*](const Future<void>& 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 Future<void>& form_result) {
          if (form_result.error() != ump::kConsentFormSuccess) {
            // form_result.error() is a kConsentFormError enum.
            LogMessage("Error showing consent form: %s", form_result.error_message());
          } else {
            // Either the form was shown and completed by the user, or consent was not required.
          }
        });
      }
    });
}

अगर आपको उपयोगकर्ता के चुनने या खारिज करने के बाद कोई कार्रवाई करने की ज़रूरत है फ़ॉर्म भरने के बाद, उस लॉजिक को उस कोड में डालें जो Future को हैंडल करता है LoadAndShowConsentFormIfRequired() ने वापस किया.

विज्ञापन जोड़ने का अनुरोध करें

अपने ऐप्लिकेशन में विज्ञापनों का अनुरोध करने से पहले, देख लें कि आपको सहमति मिली है या नहीं ConsentInfo::GetInstance()‑>CanRequestAds()का इस्तेमाल कर रहे हैं. दो सहमति लेते समय चेक करने के लिए स्थान:

मौजूदा सेशन के लिए सहमति लेने के बाद.
आपके कॉल करने के तुरंत बाद RequestConsentInfoUpdate(). ऐसा हो सकता है कि सहमति पिछले सेशन में ली गई हो. इंतज़ार के समय के तौर पर सबसे सही तरीका है, हमारा सुझाव है कि कॉलबैक पूरा होने का इंतज़ार न करें, ताकि आप ऐप्लिकेशन लॉन्च होने के बाद, विज्ञापनों को लोड करना तुरंत शुरू कर दें.

अगर सहमति इकट्ठा करने की प्रक्रिया के दौरान कोई गड़बड़ी होती है, तो आपको अब भी विज्ञापनों का अनुरोध करने की कोशिश नहीं की जाती. UMP SDK टूल, सहमति की स्थिति का इस्तेमाल करता है सत्र.

नीचे दिए गए उदाहरण में, अपडेट लूप पोलिंग का इस्तेमाल किया गया है. हालांकि, एसिंक्रोनस कार्रवाइयों को मॉनिटर करने के लिए OnCompletion कॉलबैक. इस्तेमाल की जाने वाली चीज़ें इनमें से जो भी तकनीक आपके कोड स्ट्रक्चर के साथ बेहतर तरीके से फ़िट होती है.

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

namespace gma = ::firebase::gma;
namespace ump = ::firebase::gma::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_consent = 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_state == kRequest) {
    Future<void> 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 = GetMyFormParent();
        g_consent_info->LoadAndShowConsentFormIfRequired(parent);
        g_state = kLoadAndShow;
      } else {
        LogMessage("Error requesting consent status: %s", req_result.error_message());
        g_state = kErrorState;
      }
    }
  }
  if (g_state == kLoadAndShow) {
    Future<void> 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 consent form: %s", form_result.error_message());
        g_state = kErrorState;
      }
    }
  }
  if (g_state == kInitGma && g_ads_allowed) {
    Future<gma::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;
      }
    }
  }
}

निजता के विकल्प

कुछ सहमति फ़ॉर्म के लिए, उपयोगकर्ता को किसी भी समय अपनी सहमति में बदलाव करना होता है. पालन करें निजता के विकल्प वाले बटन को लागू करने के लिए, यहां दिया गया तरीका अपनाएं.

इसके लिए:

यूज़र इंटरफ़ेस (यूआई) एलिमेंट लागू करें, जैसे कि अपने ऐप्लिकेशन के सेटिंग पेज का बटन, जो निजता विकल्प फ़ॉर्म को ट्रिगर कर सकते हैं.
पूरा LoadAndShowConsentFormIfRequired() हो जाने पर, देखें getPrivacyOptionsRequirementStatus() तय करने के लिए कि पेज को दिखाना है या नहीं यूआई एलिमेंट जो निजता के विकल्पों वाला फ़ॉर्म दिखा सकता है.
जब कोई उपयोगकर्ता आपके यूज़र इंटरफ़ेस (यूआई) एलिमेंट से इंटरैक्ट करे, तो showPrivacyOptionsForm() फ़ॉर्म दिखाने के लिए, ताकि उपयोगकर्ता ये काम कर सके निजता विकल्पों को किसी भी समय अपडेट कर सकते हैं.

टेस्ट करना

अगर आपको ऐप्लिकेशन को डेवलप करने के दौरान, अपने ऐप्लिकेशन में इंटिग्रेशन की जांच करनी है, तो यहां दिया गया तरीका अपनाएं प्रोग्राम बनाकर अपने टेस्ट डिवाइस को रजिस्टर करने के लिए, यह तरीका अपनाएं. कृपया एक कोड होता है, जो आपके ऐप्लिकेशन को रिलीज़ करने से पहले इन टेस्ट डिवाइस आईडी को सेट करता है.

RequestConsentInfoUpdate()पर कॉल करें.
नीचे दिए गए उदाहरण से मिलते-जुलते मैसेज के लिए लॉग आउटपुट देखें, जो दिखाता है कि आपका डिवाइस आईडी क्या है और इसे टेस्ट डिवाइस के तौर पर कैसे जोड़ा जा सकता है:
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]
```
अपने टेस्ट डिवाइस आईडी को क्लिपबोर्ड पर कॉपी करें.

अपने कोड को सेट में बदलें कॉलConsentRequestParameters.debug_settings.debug_device_ids के लिए आपके टेस्ट डिवाइस आईडी की सूची.

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"};

  consent_info->RequestConsentInfoUpdate(params);
}

जगह के हिसाब से कॉन्टेंट बनाना

UMP SDK टूल की मदद से, ऐप्लिकेशन के काम करने के तरीके को ऐसे टेस्ट किया जा सकता है जैसे कि डिवाइस ईईए या यूके में रहने वाले लोग हैं, जो ConsentRequestParameters.debug_settings.debug_geographyका इस्तेमाल करते हैं. ध्यान दें कि डीबग सेटिंग सिर्फ़ टेस्ट डिवाइसों पर काम करती हैं.

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"};
  // Geography appears as EEA for debug devices.
  params.debug_settings.debug_geography = ump::kConsentDebugGeographyEEA

  consent_info->RequestConsentInfoUpdate(params);
}

सहमति की स्थिति रीसेट करें

UMP SDK टूल से अपने ऐप्लिकेशन की जांच करते समय, अपडेट किया जा सकता है, ताकि आप उपयोगकर्ता के पहली बार इंस्टॉल करने के अनुभव को सिम्युलेट कर सकें. यह काम करने के लिए, SDK टूल Reset() तरीका उपलब्ध कराता है.

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