अचानक दिखने वाले विज्ञापन सेट अप करना

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

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

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

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

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

Android 

ca-app-pub-3940256099942544/1033173712

iOS 

ca-app-pub-3940256099942544/4411468910

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

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

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

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

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

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

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

export function startPreloader(
  adUnitId: string,
  preloadId: string,
  customPreloadCallback?: PreloadCallback,
): boolean {
  try {
    const started = InterstitialAdPreloader.start(
      preloadId,
      {
        request: {adUnitId},
        bufferSize: 2,
      },
      {
        // Called when an ad is preloaded into the buffer.
        onAdPreloaded: (metadata) => {
          console.log(`Interstitial ad preloaded for ${metadata.preloadId}`);
          customPreloadCallback?.onAdPreloaded?.(metadata);
        },
        // Called when an ad fails to preload.
        onAdFailedToPreload: (error: LoadAdError) => {
          console.error('Failed to preload interstitial ad:', error.message);
          customPreloadCallback?.onAdFailedToPreload?.(error);
        },
        // Called when all preloaded ads in the buffer have been shown.
        onAdsExhausted: () => {
          console.log('Preload buffer exhausted for interstitial ads.');
          customPreloadCallback?.onAdsExhausted?.();
        },
      },
    );
    return started;
  } catch (error) {
    console.error('Error starting interstitial ad preloader:', error);
    return false;
  }
}

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

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

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

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

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

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

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

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

विज्ञापन खारिज होने या डिसप्ले न होने जैसी प्रज़ेंटेशन इवेंट की जानकारी पाने के लिए, show तरीके को कॉल करने से पहले, विज्ञापन इंस्टेंस पर adEventCallback प्रॉपर्टी सेट करें.

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

export function showPreloadedAd(
  preloadId: string,
  customAdEventCallback?: FullScreenAdEventCallback,
) {
  if (InterstitialAdPreloader.isAdAvailable(preloadId)) {
    const ad = InterstitialAdPreloader.pollAd(preloadId);
    if (ad) {
      ad.adEventCallback = {
        // Called when the ad is presented on screen.
        onAdShowedFullScreenContent: () => {
          console.log('Preloaded interstitial ad showed full screen content.');
          customAdEventCallback?.onAdShowedFullScreenContent?.();
        },
        // Called when the ad is closed by the user.
        onAdDismissedFullScreenContent: () => {
          console.log('Preloaded interstitial ad dismissed.');
          customAdEventCallback?.onAdDismissedFullScreenContent?.();
          ad.destroy();
        },
        // Called when presentation fails.
        onAdFailedToShowFullScreenContent: (error) => {
          console.error('Preloaded interstitial ad failed to show:', error);
          customAdEventCallback?.onAdFailedToShowFullScreenContent?.(error);
          ad.destroy();
        },
        // Called when an impression is recorded.
        onAdImpression: () => {
          console.log('Preloaded interstitial ad recorded an impression.');
          customAdEventCallback?.onAdImpression?.();
        },
        // Called when the user taps the ad.
        onAdClicked: () => {
          console.log('Preloaded interstitial ad was clicked.');
          customAdEventCallback?.onAdClicked?.();
        },
        // Called when the ad is estimated to have earned money.
        onAdPaid: (adValue) => {
          console.log(
            `Preloaded interstitial ad paid: ${adValue.amountMicros}` +
              ` ${adValue.currencyCode}`,
          );
          customAdEventCallback?.onAdPaid?.(adValue);
        },
      };
      ad.show();
    }
  } else {
    console.log('No preloaded interstitial ad available in buffer.');
  }
}

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

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

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

export function peekPreloadedAdResponseInfo(preloadId: string) {
  if (InterstitialAdPreloader.isAdAvailable(preloadId)) {
    const responseInfo = InterstitialAdPreloader.peekAdResponseInfo(preloadId);
    if (responseInfo) {
      console.log('Next preloaded ad response info:', responseInfo);
    }
  }
}

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

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

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

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

export function destroyPreloader(preloadId: string) {
  InterstitialAdPreloader.destroy(preloadId);
}

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

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

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

export function InterstitialScreen() {
  const [numAdsAvailable, setNumAdsAvailable] = useState<number>(0);
  const [status, setStatus] = useState<string>('Initializing Preloader...');

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

  useEffect(() => {
    // Start preloading interstitial ads on component mount
    startPreloader(INTERSTITIAL_AD_UNIT_ID, PRELOAD_ID, {
      onAdPreloaded: () => {
        refreshAdCount();
        setStatus('Ad preloaded and ready!');
      },
      onAdFailedToPreload: (error) => {
        setStatus(`Preload failed: ${error.message}`);
      },
      onAdsExhausted: () => {
        refreshAdCount();
        setStatus('Preload buffer exhausted.');
      },
    });
    setStatus('Preloader started.');

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

  const handleShow = () => {
    showPreloadedAd(PRELOAD_ID, {
      onAdDismissedFullScreenContent: () => {
        setStatus('Ad dismissed.');
      },
      onAdFailedToShowFullScreenContent: (error) => {
        setStatus(`Failed to show ad: ${error.message}`);
      },
    });
    setStatus('Showing preloaded ad...');
    refreshAdCount();
  };

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

इनकी जगह ये डालें:

  • INTERSTITIAL_AD_UNIT_ID को अपने विज्ञापन यूनिट आईडी से बदलें.
  • PRELOAD_ID को अपने प्रीलोडर आईडी के साथ.

अगले चरण

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