इनाम वाले इंटरस्टीशियल विज्ञापन सेट अप करना

इनाम वाले इंटरस्टीशियल विज्ञापन, फ़ुल-स्क्रीन विज्ञापन फ़ॉर्मैट होते हैं. इनकी मदद से, स्क्रीन या गेम के लेवल के बीच दिखने वाले विज्ञापनों के लिए, ऐप्लिकेशन में खरीदने के लिए आइटम ऑफ़र किए जा सकते हैं. इनाम वाले विज्ञापनों के उलट, उपयोगकर्ताओं को विज्ञापन देखने के लिए ऑप्ट इन करने की ज़रूरत नहीं होती. ज़्यादा जानकारी के लिए, AdMob की केस स्टडी और इनाम वाले इंटरस्टीशियल विज्ञापन की यूनिट (बीटा वर्शन) की खास जानकारी देखें.

प्रज़ेंटेशन में होने वाली देरी को कम करने और ट्रांज़िशन के दौरान विज्ञापन उपलब्ध कराने के लिए, Google Mobile Ads SDK for React Native विज्ञापन लोड और कैश होने की प्रोसेस का इस्तेमाल करता है. इससे बैकग्राउंड में विज्ञापन लोड करने, कैश मेमोरी में सेव करने, और बफ़र को फिर से भरने में मदद मिलती है.

इस गाइड में, React Native ऐप्लिकेशन में विज्ञापन लोड और कैश होने की प्रोसेस के साथ, इनाम वाले इंटरस्टीशियल विज्ञापनों को इंटिग्रेट करने का तरीका बताया गया है.

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

जारी रखने से पहले, ये काम करें:

Android 

ca-app-pub-3940256099942544/5354046379

iOS 

ca-app-pub-3940256099942544/6978759866

विज्ञापन लोड और कैश होने की प्रोसेस के बारे में जानकारी

Google Mobile Ads SDK for React Native में विज्ञापन लोड और कैश होने की प्रोसेस, विज्ञापन लोड होने और कैश होने की प्रोसेस को ऑटोमेट करती है.

विज्ञापन लोड और कैश होने की प्रोसेस से ये फ़ायदे मिलते हैं:

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

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

प्रीलोड करना शुरू करें

विज्ञापनों को पहले से लोड करने के लिए, RewardedInterstitialAdPreloader.start मेथड को कॉल करें. साथ ही, बफ़र की स्थिति में होने वाले बदलावों पर नज़र रखने के लिए, preloadId वैल्यू, कॉन्फ़िगरेशन सेटिंग, और इवेंट कॉलबैक पास करें:

export function startRewardedInterstitialAdPreloader(
  adUnitId: string,
  preloadId: string,
  customPreloadCallback?: PreloadCallback,
): boolean {
  const started = RewardedInterstitialAdPreloader.start(
    preloadId,
    {
      request: {adUnitId},
      bufferSize: 2,
    },
    {
      // Called when an ad is preloaded into the buffer.
      onAdPreloaded: (event) => {
        console.log(
          `Rewarded interstitial ad preloaded for ${event.preloadId}`,
        );
        customPreloadCallback?.onAdPreloaded?.(event);
      },
      // Called when an ad fails to preload.
      onAdFailedToPreload: (error: LoadAdError) => {
        console.error(
          'Failed to preload rewarded interstitial ad:',
          error.message,
        );
        customPreloadCallback?.onAdFailedToPreload?.(error);
      },
      // Called when all preloaded ads in the buffer have been shown.
      onAdsExhausted: () => {
        console.log('Rewarded interstitial ad buffer exhausted.');
        customPreloadCallback?.onAdsExhausted?.();
      },
    },
  );
  return started;
}

preloadId एक स्ट्रिंग है, जो विज्ञापन लोड और कैश होने की प्रोसेस के कॉन्फ़िगरेशन की यूनीक तरीके से पहचान करती है. अगर आपने अपने ऐप्लिकेशन में प्रीलोडिंग के लिए सिर्फ़ एक कॉन्फ़िगरेशन के लिए विज्ञापन यूनिट आईडी का इस्तेमाल किया है, तो उस विज्ञापन यूनिट आईडी को प्रीलोड आईडी के तौर पर इस्तेमाल करें. अगर आपके ऐप्लिकेशन को एक ही विज्ञापन यूनिट का आईडी के लिए कई प्रीलोडर की ज़रूरत है, तो हर प्रीलोड आईडी के लिए अलग-अलग स्ट्रिंग पास करें.

जब आपका ऐप्लिकेशन बफ़र से पहले से लोड किए गए विज्ञापन को पोल करता है, तो Google Mobile Ads SDK for React Native बफ़र को फिर से भरने के लिए, बैकग्राउंड में विज्ञापन को बदलने का अनुरोध करता है. अगर बफ़र में पहले से लोड किया गया कोई विज्ञापन नहीं बचा है, तो Google Mobile Ads SDK for React Native, onAdsExhausted कॉलबैक को शुरू करता है.

कैश मेमोरी में पहले से लोड करने की सीमाएं

Google Mobile Ads SDK for React Native, पहले से लोड किए गए विज्ञापनों की कुल संख्या पर, पूरे ऐप्लिकेशन के लिए एक सीमा लागू करता है:

  • डिफ़ॉल्ट सीमा: Google, मेमोरी में पहले से लोड किए गए ज़्यादा से ज़्यादा छह विज्ञापन सेव रखता है. यह सीमा, सभी फ़ॉर्मैट और प्रीलोड आईडी के लिए लागू होती है.
  • सुझाया गया बफ़र: हर प्रीलोड आईडी के लिए, पहले से लोड किए गए दो विज्ञापन.

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

पोल करें और विज्ञापन दिखाएं

विज्ञापन दिखाने से पहले, RewardedInterstitialAdPreloader.isAdAvailable तरीके को कॉल करके पुष्टि करें कि विज्ञापन उपलब्ध है. विज्ञापन को वापस पाने के लिए, RewardedInterstitialAdPreloader.pollAd तरीके को कॉल करें.

विज्ञापन दिखाने के लिए, show तरीके को कॉल करें. साथ ही, onUserEarnedReward कॉलबैक का इस्तेमाल करें, ताकि उपयोगकर्ता को विज्ञापन देखने के बाद इनाम दिया जा सके. प्रज़ेंटेशन इवेंट, जैसे कि विज्ञापन खारिज होने या विज्ञापन न दिखने की समस्या के बारे में जानने के लिए, show तरीके को कॉल करने से पहले, विज्ञापन इंस्टेंस पर adEventCallback प्रॉपर्टी सेट करें.

यहां दिए गए उदाहरण में, विज्ञापन दिखाने से पहले, विज्ञापन की उपलब्धता की जांच की जाती है. साथ ही, फ़ुल-स्क्रीन प्रज़ेंटेशन इवेंट को सुना जाता है:

export function showPreloadedRewardedInterstitialAd(
  preloadId: string,
  onRewardEarned: (reward: Reward) => void,
  customAdEventCallback?: FullScreenAdEventCallback,
) {
  if (!RewardedInterstitialAdPreloader.isAdAvailable(preloadId)) {
    console.log('No preloaded rewarded interstitial ad available right now.');
    return;
  }

  const ad = RewardedInterstitialAdPreloader.pollAd(preloadId);
  if (!ad) {
    return;
  }

  ad.adEventCallback = {
    // Called when the ad is presented on screen.
    onAdShowedFullScreenContent: () => {
      console.log(
        'Preloaded rewarded interstitial ad showed full screen content.',
      );
      customAdEventCallback?.onAdShowedFullScreenContent?.();
    },
    // Called when the ad is closed by the user.
    onAdDismissedFullScreenContent: () => {
      console.log(
        'Preloaded rewarded interstitial ad dismissed full screen content.',
      );
      customAdEventCallback?.onAdDismissedFullScreenContent?.();
      ad.destroy();
    },
    // Called when presentation fails.
    onAdFailedToShowFullScreenContent: (error) => {
      console.error(
        'Failed to show preloaded rewarded interstitial ad:',
        error,
      );
      customAdEventCallback?.onAdFailedToShowFullScreenContent?.(error);
      ad.destroy();
    },
    // Called when an impression is recorded.
    onAdImpression: () => {
      console.log('Preloaded rewarded interstitial ad recorded an impression.');
      customAdEventCallback?.onAdImpression?.();
    },
    // Called when the user taps the ad.
    onAdClicked: () => {
      console.log('Preloaded rewarded interstitial ad was clicked.');
      customAdEventCallback?.onAdClicked?.();
    },
    // Called when the ad is estimated to have earned money.
    onAdPaid: (adValue) => {
      console.log(
        `Preloaded rewarded interstitial ad paid: ${adValue.amountMicros}` +
          ` ${adValue.currencyCode}`,
      );
      customAdEventCallback?.onAdPaid?.(adValue);
    },
  };

  ad.show(onRewardEarned);
}

मेमोरी और संसाधनों को रिलीज़ करने के लिए, onAdDismissedFullScreenContent और onAdFailedToShowFullScreenContent कॉलबैक में ad.destroy वाले तरीके को कॉल करें.

जवाब की जानकारी पढ़ें

कैश मेमोरी से विज्ञापन को हटाए बिना, पहले से लोड किए गए अगले विज्ञापन के रिस्पॉन्स की जानकारी देखने के लिए, RewardedInterstitialAdPreloader.peekAdResponseInfo तरीके को कॉल करें:

export function peekRewardedInterstitialAdResponseInfo(
  preloadId: string,
): ResponseInfo | null {
  const responseInfo =
    RewardedInterstitialAdPreloader.peekAdResponseInfo(preloadId);
  if (responseInfo) {
    console.log(
      'Next preloaded rewarded interstitial ad response info:',
      responseInfo,
    );
  }
  return responseInfo;
}

अगर कोई विज्ञापन उपलब्ध है, तो peekAdResponseInfo मेथड, ResponseInfo ऑब्जेक्ट दिखाता है. इसमें लोड किए गए विज्ञापन सोर्स और नेटवर्क अडैप्टर की जानकारी होती है.

ज़रूरी नहीं: एसएसवी कॉलबैक की पुष्टि करना

अगर आपके ऐप्लिकेशन को सर्वर साइड से की जाने वाली पुष्टि (एसएसवी) कॉलबैक में, पुष्टि करने के लिए कस्टम पैरामीटर की ज़रूरत है, जैसे कि यूज़र आईडी या इनाम का कस्टम मेटाडेटा, तो show तरीके को कॉल करने से पहले, पोल किए गए विज्ञापन इंस्टेंस पर serverSideVerificationOptions प्रॉपर्टी सेट करें.

आपकी सेट की गई वैल्यू, एसएसवी कॉलबैक क्वेरी पैरामीटर को पास की जाती हैं:

  • userId: उपयोगकर्ता की पहचान करने के लिए, user_id क्वेरी पैरामीटर को पास करता है.
  • customData: कस्टम मेटाडेटा को फ़ॉरवर्ड करने के लिए, custom_data क्वेरी पैरामीटर को पास करता है.

यहां दिए गए उदाहरण में, विज्ञापन दिखाने से पहले, इनाम वाले इंटरस्टीशियल विज्ञापन ऑब्जेक्ट पर ServerSideVerificationOptions (customData और userId) सेट किया गया है:

export function setServerSideVerificationRewardedInterstitial(
  ad: RewardedInterstitialAd,
) {
  ad.serverSideVerificationOptions = {
    userId: 'user_123',
    customData: 'sample_custom_data',
  };
}

संसाधन मिटाना

अगर आपको सेशन के बाकी हिस्से के लिए, किसी खास प्रीलोड आईडी के विज्ञापन नहीं दिखाने हैं, तो RewardedInterstitialAdPreloader.destroy तरीके को कॉल करें. इस प्रोसेस से, उस प्रीलोड आईडी के लिए पहले से लोड करना बंद हो जाता है. साथ ही, इस्तेमाल नहीं किए गए पहले से लोड किए गए विज्ञापनों को मेमोरी से हटा दिया जाता है.

यहां दिए गए उदाहरण में, प्रीलोडिंग को रोकने का तरीका बताया गया है:

export function destroyRewardedInterstitialAdPreloader(preloadId: string) {
  RewardedInterstitialAdPreloader.destroy(preloadId);
}

जब उपयोगकर्ता विज्ञापन को खारिज कर दे या विज्ञापन न दिखे, तो पोल किए गए विज्ञापन के अलग-अलग इंस्टेंस को खत्म कर दें. ज़्यादा जानकारी के लिए, पोल करें और विज्ञापन दिखाएं लेख पढ़ें.

पूरा उदाहरण देखें

इस सेक्शन में, विज्ञापन लोड और कैश होने की प्रोसेस को पूरी तरह से लागू करने के बारे में बताया गया है.

यहां दिए गए कॉम्पोनेंट का उदाहरण, माउंट पर पहले से लोड करना शुरू करता है. साथ ही, उपलब्ध विज्ञापनों की संख्या को ट्रैक करता है. इसके अलावा, इनाम वाले इंटरस्टीशियल विज्ञापनों को पहले से लोड करके दिखाने के लिए कंट्रोल उपलब्ध कराता है:

export function RewardedInterstitialScreen() {
  const [numAdsAvailable, setNumAdsAvailable] = useState<number>(0);
  const [status, setStatus] = useState<string>('Preloader idle.');
  const [reward, setReward] = useState<string | null>(null);

  const refreshAdCount = () => {
    const count =
      RewardedInterstitialAdPreloader.getNumAdsAvailable(PRELOAD_ID);
    setNumAdsAvailable(count);
  };

  useEffect(() => {
    // Start preloading ads on component mount
    const started = startRewardedInterstitialAdPreloader(
      REWARDED_INTERSTITIAL_AD_UNIT_ID,
      PRELOAD_ID,
      {
        onAdPreloaded: () => {
          refreshAdCount();
          setStatus('Rewarded interstitial ad preloaded into buffer.');
        },
        onAdFailedToPreload: (error) => {
          setStatus(
            `Failed to preload rewarded interstitial ad: ${error.message}`,
          );
        },
        onAdsExhausted: () => {
          refreshAdCount();
          setStatus('Preload buffer exhausted for rewarded interstitial ads.');
        },
      },
    );
    if (started) {
      setStatus('Preloader started.');
    }

    // Clean up preloader resources on component unmount
    return () => {
      destroyRewardedInterstitialAdPreloader(PRELOAD_ID);
    };
  }, []);

  const handleShowAd = () => {
    setReward(null);
    setStatus('Showing preloaded ad...');
    showPreloadedRewardedInterstitialAd(
      PRELOAD_ID,
      (userReward) => {
        setReward(`${userReward.amount} ${userReward.type}`);
      },
      {
        onAdDismissedFullScreenContent: () => {
          setStatus('Ad dismissed.');
        },
        onAdFailedToShowFullScreenContent: (error) => {
          setStatus(`Failed to show preloaded ad: ${error.message}`);
        },
      },
    );
    refreshAdCount();
  };

  return (
    <View style={styles.container}>
      <Text style={styles.title}>Preload Rewarded Interstitial Ads</Text>
      <Text style={styles.status}>Status: {status}</Text>
      <Text style={styles.status}>Ads Available: {numAdsAvailable}</Text>
      {reward && <Text style={styles.rewardText}>Earned: {reward}</Text>}
      <View style={styles.buttonGroup}>
        <Button
          title="Show Preloaded Ad"
          onPress={handleShowAd}
          disabled={numAdsAvailable === 0}
        />
      </View>
    </View>
  );
}

अगले चरण

इनाम वाले इंटरस्टीशियल विज्ञापनों को इंटिग्रेट करने के बाद, इन विषयों के बारे में जानें: