यह गाइड, उन विज्ञापन नेटवर्क कंपनियों के लिए है जो Google के मीडिएशन में रीयल-टाइम बिडिंग (आरटीबी) में हिस्सा लेने के लिए, बिडिंग अडैप्टर बनाना चाहती हैं. अगर आप पब्लिशर हैं, तो पब्लिशर के लिए मीडिएशन के निर्देश देखें.
बिडिंग अडैप्टर, इंटिग्रेशन का क्लाइंट-साइड हिस्सा होता है. अडैप्टर की मदद से, आपकी विज्ञापन नेटवर्क कंपनी का SDK टूल, Google Mobile Ads SDKसे कम्यूनिकेट कर पाता है. इससे, आपके बिडर की मदद से दिखाए जाने वाले विज्ञापन लोड किए जा सकते हैं.
बिडिंग के सही तरीके से काम करने के लिए, आपके अडैप्टर को इन चीज़ों को मैनेज करना होगा: डेटा लेयर में इवेंट बनाने की प्रोसेस, सिग्नल इकट्ठा करना, विज्ञापन लोड करना, और विज्ञापन के लाइफ़साइकल इवेंट को रिले करना. इस गाइड में, हम आपको बताएंगे कि इन कार्रवाइयों को मैनेज करने के लिए, आपके अडैप्टर को कैसे लागू किया जाना चाहिए.
बिडिंग अडैप्टर का वर्कफ़्लो
डेटा लेयर में इवेंट बनाने की प्रोसेस
यहां, अडैप्टर के अनुरोध-जवाब-रेंडरिंग के पूरे लाइफ़साइकल का विस्तृत फ़्लो दिखाया गया है:
अडैप्टर, वर्कफ़्लो के इन हिस्सों के लिए ज़िम्मेदार होता है:
चौथे से सातवें चरण: अपने अडैप्टर को शुरू करें और Google Mobile Ads SDK डेटा लेयर में इवेंट बनाने की प्रोसेस पूरी होने के बाद, Google Mobile Ads SDK को कॉलबैक करें.
10वें से 13वें चरण: अपने विज्ञापन नेटवर्क कंपनी के SDK टूल से सिग्नल इकट्ठा करें. इन्हें आरटीबी के अनुरोध में हिस्सा लेने के लिए, अपने बिडर को भेजें. साथ ही, इन्हें Google Mobile Ads SDK को फ़ॉरवर्ड करें.
18वें से 21वें चरण: अगर आपका बिडर, जीतने वाली बिड दिखाता है, तो अपने बिडर से मिले जवाब के मुताबिक विज्ञापन लोड करें. लोड होने के बाद, Google Mobile Ads SDK को सूचना दें कि विज्ञापन लोड हो गया है.
23वें चरण और उसके बाद: जब आपका विज्ञापन दिख रहा हो, तब Google Mobile Ads 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 Ads SDK की ओर से तय किए गए "विज्ञापन" इंटरफ़ेस में से किसी एक के मुताबिक हो. इन विज्ञापन इंटरफ़ेस के लिए, आपको विज्ञापन के बारे में कुछ जानकारी देनी होगी.
MediationAdConfiguration में, getWatermark()
तरीका भी होता है. इससे base64-एनकोड की गई स्ट्रिंग मिलती है. यह स्ट्रिंग, पीएनजी इमेज को दिखाती है. इस इमेज को, आपके विज्ञापनों पर पारदर्शी ओवरले में टाइल किया जाना चाहिए.
वॉटरमार्क रेंडर करने के तरीके के बारे में ज़्यादा जानकारी पाने के लिए, 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 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.onSuccess() को कॉल करने पर, MediationAdLoadCallback<MediationAdT, MediationAdCallbackT>
ऑब्जेक्ट वापस मिलता है. अडैप्टर से उम्मीद की जाती है कि वे इस ऑब्जेक्ट को सेव करें और इसका इस्तेमाल, आपके विज्ञापन पर होने वाले विज्ञापन दिखाने के इवेंट को लागू करने के लिए करें.
आम तौर पर, इनमें से ज़्यादातर इवेंट, आपकी विज्ञापन नेटवर्क कंपनी के SDK टूल की मदद से होते हैं. अडैप्टर की भूमिका, आपकी विज्ञापन नेटवर्क कंपनी के SDK टूल से मिलने वाले कॉलबैक को Google Mobile Ads SDK पर मैप करना है.
यहां दिए गए उदाहरण में बताया गया है कि अपने SDK टूल के विज्ञापन लिसनर से मिलने वाले कॉलबैक को Google Mobile Ads 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 नेटिव विज्ञापन के लिए इंप्रेशन तब रिकॉर्ड करता है, जब विज्ञापन का 1 पिक्सल दिखता है. अगर आपकी विज्ञापन नेटवर्क कंपनी के एसडीके टूल को, मान्य इंप्रेशन रेंडर करने के लिए, कुछ खास ऐसेट दिखाने की ज़रूरत होती है, तो आपका बिडर, बिड रिस्पॉन्स में इन ज़रूरी नेटिव ऐसेट के बारे में बता सकता है. Google Mobile Ads SDK इसके बाद, यह पुष्टि करता है कि इंप्रेशन रिकॉर्ड करने से पहले, आपकी ज़रूरी नेटिव ऐसेट दिखाई गई हैं.
बिड के जवाब में, ज़रूरी ऐसेट के बारे में बताने के तरीके के बारे में ज़्यादा जानने के लिए, नेटिव विज्ञापन के लिए ज़रूरी ऐसेट से जुड़ा दस्तावेज़ देखें.
विज्ञापन की गड़बड़ियां दिखाना
फ़ुल स्क्रीन फ़ॉर्मैट के लिए, जैसे कि इंटरस्टीशियल और इनाम वाले विज्ञापन, लोड होने के बाद मिलने वाले कॉलबैक में, आपको
को लागू करने की जानकारी देनी होगी. इससे Google Mobile Ads SDK आपके अडैप्टर से विज्ञापन दिखाने के लिए कह सकता है.MediationInterstitialAdMediationRewardedAd
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, ...);
}
}