बिडिंग अडैप्टर डेवलपमेंट

यह गाइड, उन विज्ञापन नेटवर्क कंपनियों के लिए है जो बिडिंग अडैप्टर बनाना चाहती हैं ताकि Google मीडिएशन में रीयल-टाइम बिडिंग (आरटीबी) में हिस्सा लिया जा सके. अगर आपको पब्लिशर हैं, तो पब्लिशर मीडिएशन देखें निर्देश.

बिडिंग अडैप्टर, इंटिग्रेशन का क्लाइंट-साइड हिस्सा होता है. अडैप्टर आपकी विज्ञापन नेटवर्क कंपनी के SDK टूल को Google Mobile Ads SDK से संपर्क करने में मदद करता है आपके बिडर से दिखाए जाने वाले विज्ञापन लोड नहीं करने चाहिए.

सही तरीके से काम करने के लिए बोली लगाने के लिए, आपके अडैप्टर को शुरू करना, सिग्नल इकट्ठा करना, विज्ञापन लोड करना, और विज्ञापन का लाइफ़साइकल दिखाना इवेंट. इस गाइड में हम आपको बताएंगे कि आपका अडैप्टर कैसा होना चाहिए इन कार्रवाइयों को मैनेज करने के लिए, इसे लागू किया जाता है.

बिडिंग अडैप्टर का वर्कफ़्लो

डेटा लेयर में इवेंट बनाने की प्रोसेस

अनुरोध के रिस्पॉन्स को रेंडर करने की पूरी लाइफ़साइकल की पूरी जानकारी की नीचे दिखाई गई है:

अडैप्टर, वर्कफ़्लो के इन हिस्सों के लिए ज़िम्मेदार होता है:

  • चौथे से सातवें चरण: अडैप्टर को शुरू करना और Google Mobile Ads SDK को वापस कॉल करना शुरू करने के बाद.

  • चरण 10 से 13: अपने विज्ञापन नेटवर्क के SDK टूल से सिग्नल इकट्ठा करें, ताकि आरटीबी अनुरोध में हिस्सा लेने और उन्हें Google Mobile पर फ़ॉरवर्ड करने के लिए Google Ads SDK टूल.

  • चरण 18-21: अगर बिड करने वाले व्यक्ति को जीतने वाली बिड दिखती है, तो उसके हिसाब से विज्ञापन लोड करें बिड करने वाले के जवाब पर क्लिक करें. लोड होने के बाद, Google Mobile Ads SDK को सूचित करें विज्ञापन लोड हुआ.

  • चरण 23 और बाद का चरण: अपना विज्ञापन प्रदर्शित होते समय Google मोबाइल विज्ञापनों को सूचित करें इंप्रेशन और क्लिक इवेंट के साथ-साथ होने वाले अन्य विज्ञापन इवेंट के SDK टूल के दौरान लंबे समय तक इस्तेमाल किया जा सकता है.

बिडिंग अडैप्टर लागू करना

अगर आपको Google Mobile Ads SDK के लिए बिडिंग अडैप्टर बनाना है, तो RtbAdapter ऐब्सट्रैक्ट क्लास को बढ़ाएं. ये सेक्शन RtbAdapter में दिए गए हर ऐब्सट्रैक्ट तरीके के बारे में बताएं.

getSDKVersionInfo()

यहां आपको अपने SDK टूल का वर्शन दिखाना होगा. यह वर्शन आपके जो OpenRTB अनुरोध के हिस्से के तौर पर बिड करने वाले के लिए हों.

इस तरीके का इस्तेमाल करने के लिए, आपको VersionInfo देना होगा. नीचे दिए गए उदाहरण में बताया गया है कि तो अपने SDK टूल के स्ट्रिंग वर्शन को VersionInfo. में बदला जा सकता है

@Override
public VersionInfo getSDKVersionInfo() {
  // Get your SDK's version as a string. E.g. "1.2.3"
  // String versionString = YourSdk.getVersion();
  String splits[] = versionString.split("\\.");
  if (splits.length >= 3) {
      int major = Integer.parseInt(splits[0]);
      int minor = Integer.parseInt(splits[1]);
      int micro = Integer.parseInt(splits[2]);
      return new VersionInfo(major, minor, micro);
   }

   String logMessage = String.format("Unexpected SDK version format: %s." +
           "Returning 0.0.0 for SDK version.", sdkVersion);
   Log.w(TAG, logMessage);
   return new VersionInfo(0, 0, 0);
}

getVersionInfo()

यहां आपको अपने अडैप्टर का वर्शन दिखाना चाहिए. यह वर्शन आपके जो OpenRTB अनुरोध के हिस्से के तौर पर बिड करने वाले के लिए हों.

Google का ओपन सोर्स और वर्शन अडैप्टर चार अंकों वाली अडैप्टर वर्शन स्कीम का इस्तेमाल करती है, लेकिन VersionInfo सिर्फ़ तीन अंकों वाली अंक. इससे बचने के लिए, आखिरी दो अंकों को एक साथ रखने का सुझाव दिया जाता है पैच वर्शन में, जैसा कि नीचे दिखाया गया है.

@Override
public VersionInfo getVersionInfo() {
  // Get your adapters's version as a string. E.g. "1.2.3.0"
  String versionString = BuildConfig.VERSION_NAME;
  String splits[] = versionString.split("\\.");
  if (splits.length >= 4) {
      int major = Integer.parseInt(splits[0]);
      int minor = Integer.parseInt(splits[1]);
      int micro = Integer.parseInt(splits[2]) * 100 + Integer.parseInt(splits[3]);
      return new VersionInfo(major, minor, micro);
    }

    String logMessage = String.format("Unexpected adapter version format: %s." +
                "Returning 0.0.0 for adapter version.", versionString);
    Log.w(TAG, logMessage);
    return new VersionInfo(0, 0, 0);
}

initialize()

टाइम आउट: 30 सेकंड

initialize() तरीका, आपके अडैप्टर में कॉल किया जाने वाला पहला तरीका है. हां हर सेशन में सिर्फ़ एक बार कॉल किया जाता है. इस तरीके से, आपको MediationConfiguration ऑब्जेक्ट जो इसकी पूरी सूची दिखाते हैं इस ऐप्लिकेशन में मौजूद ऐसे प्लेसमेंट जिन्हें आपके विज्ञापन नेटवर्क के लिए कॉन्फ़िगर किया गया है; आप लूप कर सकते हैं इस सूची की मदद से, हर प्लेसमेंट के क्रेडेंशियल को पार्स कर सकते हैं. शुरू करने के लिए, अपने SDK टूल को ज़रूरी डेटा भेजें.

जब आपका SDK टूल शुरू हो जाए और वह विज्ञापन अनुरोध पाने के लिए तैयार हो, तो InitializationCompleteCallback में से onInitializationSucceeded() तरीका. इस कॉलबैक को ऐप्लिकेशन पब्लिशर को फ़ॉरवर्ड किया जाता है, ताकि वे जान सकें विज्ञापनों को लोड करना शुरू कर सकता है.

@Override
public void initialize(Context context,
    InitializationCompleteCallback initializationCompleteCallback,
    List<MediationConfiguration> mediationConfigurations) {
  // Initialize your ad network's SDK.
  ...

  // Invoke the InitializationCompleteCallback once initialization completes.
  initializationCompleteCallback.onInitializationSucceeded();
}

collectSignals()

टाइम आउट: 1 सेकंड

जब भी पब्लिशर किसी विज्ञापन का अनुरोध करता है, तब आपके RtbAdapter का एक नया इंस्टेंस यह होता है बनाई गई और collectSignals() तरीके को कॉल किया गया. इस मामले में RtbAdapter का इस्तेमाल तब तक किया जाएगा, जब तक विज्ञापन अनुरोध, रिस्पॉन्स, और उस विज्ञापन की लाइफ़साइकल रेंडर हो जाएगी. collectSignals() तरीका इस्तेमाल करने पर, अडैप्टर, डिवाइस से सिग्नल देने के लिए जो आपके बिडर को भेजे जाते हैं OpenRTB अनुरोध.

collectSignals() को बैकग्राउंड थ्रेड पर कॉल किया जा रहा है. Google Mobile Ads SDK, सभी अडैप्टर से सिग्नल एक साथ मांगता है बिडिंग में हिस्सा ले रहे हैं. कृपया सम्मानजनक भाषा का इस्तेमाल करें. साथ ही, कॉल को यूज़र इंटरफ़ेस (यूआई) थ्रेड पर सीमित करें इस दौरान. इकट्ठा करने के लिए हर ऐसा काम जो आपके अडैप्टर या SDK टूल को करना पड़ सकता है सिग्नल, initialize() तरीके से किए जाने चाहिए और कैश मेमोरी में सेव किए जाने चाहिए.

अपने सिग्नल तैयार होने के बाद, onSuccess() कॉलबैक को अपने कोड में बदले गए सिग्नल.

यहां इसे लागू करने का एक उदाहरण दिया गया है:

@Override
public void collectSignals(RtbSignalData rtbSignalData,
                           SignalCallbacks signalCallbacks) {
  String signals = YourSdk.getSignals();
  signalCallbacks.onSuccess(signals);
}

अगर अडैप्टर सिग्नल इकट्ठा नहीं कर पाता है, तो signalCallbacks.onFailure() पर कॉल करें होने वाली गड़बड़ी के बारे में जानकारी देने वाली स्ट्रिंग के साथ.

विज्ञापन लोड करने के तरीके लागू करें

टाइम आउट: 10 सेकंड

अगर बिड करने वाला व्यक्ति जीतने वाली बिड दिखाता है, तो Google Mobile Ads SDK टूल जीतने वाले विज्ञापन को लोड करने के लिए आपके अडैप्टर को कॉल करता है और आपको वह डेटा पास करता है जो बोली लगाने वाले ने बताया कि आपके SDK टूल को वह विज्ञापन लोड करना होगा.

लोड करने का सटीक तरीका विज्ञापन के हिसाब से तय होता है इस अनुरोध का फ़ॉर्मैट:

विज्ञापन फ़ॉर्मैट लोड करने का तरीका
बैनर loadBannerAd()
मध्यवर्ती loadInterstitialAd()
इनाम दिया गया loadRewardedAd()

उन विज्ञापन फ़ॉर्मैट के लिए ये तरीके लागू करें जो आपके अडैप्टर के साथ काम करते हैं.

लोड करने का तरीका, यूज़र इंटरफ़ेस (यूआई) थ्रेड पर कॉल किया जाता है. यह वही इंस्टेंस होता है जिससे आपने सिग्नल दिए थे. इस तरीके से आपको ये सुविधाएं मिलेंगी पैरामीटर:

  • MediationAdConfiguration, जिसमें ऐसे पैरामीटर होते हैं जो आपके SDK टूल के लिए ज़रूरी हैं सफल बिड के लिए विज्ञापन लोड करती है, जैसे कि बिड रिस्पॉन्स और क्रेडेंशियल AdMob यूज़र इंटरफ़ेस (यूआई) में कॉन्फ़िगर किया गया पब्लिशर.

  • MediationAdLoadCallback ऑब्जेक्ट का इस्तेमाल, Google Mobile Ads SDK को सूचित करने के लिए किया जाता है लोड होने के पूरा या बंद होने पर.

जब आपका SDK टूल विज्ञापन लोड कर दे, तब mediationAdLoadCallback.onSuccess() को कॉल करें. इस इवेंट के विज्ञापन को लोड नहीं किया जा सका, इसके साथ mediationAdLoadCallback.onFailure() को कॉल करें गड़बड़ी के बारे में जानकारी देने वाली स्ट्रिंग.

mediationAdLoadCallback.onSuccess() तरीके के लिए ज़रूरी है कि आप ऐसा ऑब्जेक्ट जो किसी "विज्ञापन" की पुष्टि करता हो Google Mobile की ओर से तय किए गए इंटरफ़ेस Google Ads SDK टूल. ये विज्ञापन इंटरफ़ेस आपको विज्ञापन के बारे में कुछ जानकारी देने के लिए कहते हैं.

MediationAdConfiguration के पास getWatermark() भी है करने का तरीका बताया गया है. यह इमेज उन्हें विज्ञापनों के ऊपर पारदर्शी ओवरले में टाइल किया जाना चाहिए. वॉटरमार्क को रेंडर करने के तरीके के बारे में ज़्यादा जानकारी पाने के लिए, Google से संपर्क करें. इसमें यह मेटाडेटा शामिल होता है कि प्रकाशक, विज्ञापन का इस्तेमाल यह तय करने के लिए करते हैं दिखाए जाने वाले विज्ञापनों का सोर्स होता है.

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

नीचे loadBannerAd() को लागू करने का सैंपल दिया गया है. इन बातों का ध्यान रखें आपके अडैप्टर को लागू करने का तरीका अलग दिखेगा, जैसे कि अडैप्टर किसी अन्य SDK टूल के साथ इंटिग्रेट करता है.

public final class SampleRtbAdapter extends RtbAdapter {
  ...

  @Override
  public void loadBannerAd(
      MediationBannerAdConfiguration adConfiguration,
      MediationAdLoadCallback<MediationBannerAd, MediationBannerAdCallback> callback) {

      SampleBannerRenderer bannerRenderer =
          new SampleBannerRenderer(adConfiguration, callback);
      bannerRenderer.render();
    }
}

// Renders a banner ad, and forwards callbacks to the Google Mobile Ads SDK.
public class SampleBannerRenderer implements MediationBannerAd {
  private MediationBannerAdConfiguration adConfiguration;
  private final MediationAdLoadCallback<MediationBannerAd, MediationBannerAdCallback> adLoadCallback;
  private AdView adView;
  private MediationBannerAdCallback callback;

  public SampleRtbBannerRenderer(
      MediationBannerAdConfiguration adConfiguration,
      MediationAdLoadCallback<MediationBannerAd, MediationBannerAdCallback> adLoadCallback) {
    this.adConfiguration = adConfiguration;
    this.adLoadCallback = adLoadCallback;
  }

  public void render() {
    adView = new AdView(adConfiguration.getContext());
    adView.setAdSize(adConfiguration.getAdSize());
    // serverParameters are the parameters entered in the AdMob UI for your network.
    adView.setAdUnitId(adConfiguration.getServerParameters().getString("adUnitId"));

    // Map the callbacks from your SDK to Google's SDK.
    adView.setAdListener(new AdListener() {
      // See the next step for more information on callback mapping.
      // ...
    });

    // Get the bid response and watermark from the ad configuration and
    // pass the relevant information to your SDK.
    String ad = adConfiguration.getBidResponse();
    String watermark = adConfiguration.getWatermark();
    Bundle extras = new Bundle();
    extras.putString("bid", ad);
    extras.putString("watermark", watermark);
    AdRequest request = new AdRequest.Builder()
        .addNetworkExtrasBundle(AdMobAdapter.class, extras)
        .build();
    adView.loadAd(request);
  }

  // MediationBannerAd implementation

  @NonNull
  @Override
  public View getView() {
    return adView;
  }
}

रिले विज्ञापन के प्रज़ेंटेशन की लाइफ़साइकल इवेंट

अडैप्टर की आखिरी ज़िम्मेदारी, Google Mobile Ads SDK को सूचित करना होती है ताकि उन्हें प्रज़ेंटेशन के लिए फ़ॉरवर्ड किया जा सके प्रकाशक हैं. पब्लिशर को किसी खास समय पर इन कॉलबैक की ज़रूरत होती है, भले ही कौनसा विज्ञापन नेटवर्क विज्ञापन दिखाता है, इसलिए यह ज़रूरी है कि इनमें से जितने कॉलबैक सही समय पर और सही से शुरू किए जाएं, ताकि Google Mobile Ads SDK से उन्हें पब्लिशर को भेजा जा सकता है.

लागू होने पर, अडैप्टर को ये इवेंट शुरू करने चाहिए:

सभी फ़ॉर्मैट के लिए सामान्य
तरीका कॉल कब करना चाहिए
reportAdClicked() विज्ञापन पर क्लिक किया गया था.
reportAdImpression() विज्ञापन ने एक इंप्रेशन रेंडर किया.
onAdOpened() विज्ञापन में फ़ुल स्क्रीन व्यू दिखाया गया.
onAdClosed() विज्ञापन का फ़ुल स्क्रीन व्यू बंद कर दिया गया है.
onAdLeftApplication() विज्ञापन की वजह से उपयोगकर्ता को ऐप्लिकेशन से बाहर निकलना पड़ा.
इनाम वाले विज्ञापन
onRewarded() उपयोगकर्ता को इनाम दिया जाता है.
वीडियो कॉलबैक (इनाम वाले विज्ञापन और नेटिव विज्ञापन)
onVideoStarted() विज्ञापन का वीडियो शुरू हो गया.
onVideoCompleted() विज्ञापन का वीडियो पूरा हो गया.

अडैप्टर को MediationAdLoadCallback<MediationAdT, MediationAdCallbackT> मिलता है mediationAdLoadCallback.onSuccess() को कॉल करने पर ऑब्जेक्ट को वापस कॉल करें. अडैप्टर यह हैं उम्मीद की जाती है कि इस ऑब्जेक्ट को होल्ड करके रखा जाएगा और प्रज़ेंटेशन इवेंट शुरू करने के लिए इसका इस्तेमाल किया जाएगा जो आपके विज्ञापन पर होते हैं.

आम तौर पर, इनमें से ज़्यादातर इवेंट आपके विज्ञापन नेटवर्क के SDK टूल की मदद से होते हैं. कॉन्टेंट बनाने अडैप्टर का काम बस आपके विज्ञापन नेटवर्क SDK टूल से कॉलबैक को Google मोबाइल विज्ञापन SDK टूल.

नीचे दिया गया उदाहरण दिखाता है कि अपने Google Mobile Ads SDK को SDK टूल का विज्ञापन लिसनर:

adView.setAdListener(new AdListener() {
    public void onAdLoaded() {
        callback = adLoadCallback.onSuccess(SampleBannerRenderer.this);
    }

    public void onAdImpression() {
        if (callback != null) {
            callback.reportAdImpression();
        }
    }

    public void onAdFailedToLoad(LoadAdError adError) {
        adLoadCallback.onFailure("Error: " + adError.toString());
    }

    public void onAdClosed() {
        if (callback != null) {
            callback.onAdClosed();
        }
    }

    public void onAdOpened() {
        if (callback != null) {
            callback.onAdOpened();
            callback.reportAdClicked();
        }
    }

    public void onAdLeftApplication() {
        if (callback != null) {
            callback.onAdLeftApplication();
        }
    }
});

नेटिव विज्ञापन इंप्रेशन ट्रैकिंग के लिए ज़रूरी एसेट

Google Mobile Ads SDK, नेटिव विज्ञापन के लिए इंप्रेशन तब रिकॉर्ड करता है, जब विज्ञापन दिखाई देता है. अगर आपके विज्ञापन नेटवर्क SDK टूल को खास एसेट दिखाने की ज़रूरत है मान्य इंप्रेशन दिखाने के लिए, बिड करने वाला व्यक्ति इन ज़रूरी शर्तों के बारे में बता सकता है बिड रिस्पॉन्स में नेटिव ऐसेट शामिल की जाती हैं. इसके बाद, Google Mobile Ads SDK उसकी पुष्टि करता है आपकी ज़रूरी नेटिव ऐसेट, इंप्रेशन रिकॉर्ड करने से पहले दिखती हैं.

नेटिव के लिए ज़रूरी ऐसेट देखें दस्तावेज़ बिड में अन्य ज़रूरी ऐसेट जोड़ने के तरीके के बारे में ज़्यादा जानकारी जवाब.

विज्ञापन से जुड़ी गड़बड़ियां दिखाएं

इंटरस्टीशियल विज्ञापनों और इनाम वाले विज्ञापनों जैसे फ़ुल स्क्रीन फ़ॉर्मैट के लिए लोड कॉलबैक के बाद, आप अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है MediationInterstitialAd या MediationRewardedAd ताकि Google Mobile Ads SDK आपके अडैप्टर से विज्ञापन दिखाने के लिए कह सके.

Google Mobile Ads SDK के मुताबिक, यह उम्मीद की जाती है कि अगर किसी अडैप्टर ने किसी विज्ञापन को सही तरीके से लोड किया, प्रकाशक के निर्देश देने पर विज्ञापन दिखाए जाने के लिए तैयार रहता है. इसका मतलब है कि हर शो के कॉल से एक इंप्रेशन मिलना चाहिए.

हालांकि, कुछ ऐसे भी मामले हो सकते हैं जहां आप विज्ञापन न दिखा पाएं. अगर आपको विज्ञापन नहीं दिखा सकते, तो अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है onAdFailedToShow() कॉलबैक का इस्तेमाल करें.

नीचे दी गई टेबल में दिखाया गया है कि प्रज़ेंटेशन कॉलबैक, फ़ुल स्क्रीन वाले विज्ञापन फ़ॉर्मैट के लिए इंप्रेशन रिकॉर्डिंग पर कैसे असर डालते हैं:

कॉलबैक नतीजा
onAdOpened() Impression recorded
onAdFailedToShow() Impression failure1
कई सेकंड के लिए, इनमें से कोई नहीं Impression recorded

1 विफल के लिए इंप्रेशन के लिए, आपकी विज्ञापन नेटवर्क कंपनी से इंप्रेशन का शुल्क नहीं लिया जाता, आपके बिल करने लायक इवेंट रेट के अडजस्टमेंट पर असर पड़ता है. बोली अनुरोध देखें देखने के लिए, जानकारी.

नीचे दिया गया मॉक उदाहरण उस लोड/शो लाइफ़साइकल को दिखाता है जिसमें कोई विज्ञापन शो कॉल के नतीजे में विफल हो सकता है.

final class SampleRtbAdapter extends RtbAdapter implements MediationRewardedAd {

 private MediationRewardedAdCallback callback;
 private RewardedAd rewardedAd;

 ...

  @Override
  public void loadRewardedAd(
      MediationRewardedAdConfiguration adConfiguration,
      final MediationAdLoadCallback<MediationRewardedAd, MediationRewardedAdCallback> loadCallback) {

    // Load an ad. This mock example uses Google's SDK, but in practice
    // your adapter will load the ad using your ad network's SDK.
    RewardedAd.load(adConfiguration.getContext(),
        "ca-app-pub-3940256099942544/5224354917",
        new AdRequest.Builder().build(),
        new RewardedAdLoadCallback() {
          @Override
          public void onAdLoaded(@NonNull RewardedAd rewardedAd) {
            // When the ad loads, invoke the load success callback.
            callback = loadCallback.onSuccess(SampleRtbAdapter.this);
          }
        });
  }

  @Override
  public void showAd(Context context) {
    // In this mock example, your ad network requires an activity context, but
    // didn't receive one, making you unable to show the ad.
    if (!(context instanceof Activity)) {
      AdError error = new AdError(1, "Context must be an activity",
          "com.google.ads.mediation.sample");
      callback.onAdFailedToShow(error);
    }

    // This example shows Google SDK's callbacks, but it's likely your SDK
    // has similar presentation callbacks.
    rewardedAd.setFullScreenContentCallback(new FullScreenContentCallback() {
      @Override
      public void onAdShowedFullScreenContent() {
        // Your ad network SDK successfully showed the ad. Call onAdOpened().
        callback.onAdOpened();
      }

      @Override
      public void onAdFailedToShowFullScreenContent(AdError adError) {
        // Your ad network SDK failed to show the ad, invoke onAdFailedToShow.
        // In practice, you will map your SDK's error to an AdError.
        AdError error = new AdError(adError.getCode(), adError.getMessage(),
            adError.getDomain());
        callback.onAdFailedToShow(adError);
      }
    });


    rewardedAd.show((Activity) context, ...);
  }
}