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

ऐप्लिकेशन खोलने पर दिखने वाले विज्ञापन

यह गाइड, ऐप्लिकेशन खोलने पर दिखने वाले विज्ञापनों को इंटिग्रेट करने वाले पब्लिशर के लिए है.

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

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

ऐप्लिकेशन खोलने पर दिखने वाले विज्ञापनों को लागू करने के लिए, यह तरीका अपनाएं:

एक मैनेजर क्लास बनाएं, जो विज्ञापन दिखाने से पहले उसे लोड कर ले.
ऐप्लिकेशन के फ़ोरग्राउंड इवेंट के दौरान विज्ञापन दिखाएं.
प्रज़ेंटेशन कॉलबैक मैनेज करना.

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

शुरू करने के लिए बनी हमारी गाइड में दिए गए सेटअप निर्देशों का पालन करें.
अपने डिवाइस को टेस्ट डिवाइस के तौर पर कॉन्फ़िगर करने का तरीका जानें.

हमेशा टेस्ट विज्ञापनों की मदद से जांच करें

अपने ऐप्लिकेशन बनाते और टेस्ट करते समय, लाइव और प्रोडक्शन विज्ञापनों के बजाय, टेस्ट विज्ञापनों का इस्तेमाल करें. ऐसा न करने पर, आपके खाते को निलंबित किया जा सकता है.

टेस्ट विज्ञापन लोड करने का सबसे आसान तरीका, ऐप्लिकेशन के खुले विज्ञापनों के लिए, हमारे खास टेस्ट विज्ञापन यूनिट आईडी का इस्तेमाल करना है:

/21775744923/example/app-open

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

Mobile Ads SDK के टेस्ट विज्ञापनों के काम करने के तरीके के बारे में ज़्यादा जानने के लिए, टेस्ट विज्ञापन लेख पढ़ें.

मैनेजर क्लास लागू करना

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

AppOpenAdManager नाम की एक नई सिंगलटन क्लास बनाएं और उसे इस तरह से भरें:

Swift

class AppOpenAdManager: NSObject {
  var appOpenAd: GADAppOpenAd?
  var isLoadingAd = false.
  var isShowingAd = false

  static let shared = AppOpenAdManager()

  private func loadAd() async {
    // TODO: Implement loading an ad.
  }

  func showAdIfAvailable() {
    // TODO: Implement showing an ad.
  }

  private func isAdAvailable() -> Bool {
    // Check if ad exists and can be shown.
    return appOpenAd != nil
  }
}

Objective-C

@interface AppOpenAdManager ()
@property(nonatomic, strong) GADAppOpenAd *appOpenAd;
@property(nonatomic, assign) BOOL isLoadingAd;
@property(nonatomic, assign) BOOL isShowingAd;

@end

@implementation AppOpenAdManager

+ (nonnull AppOpenAdManager *)sharedInstance {
  static AppOpenAdManager *instance = nil;
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
    instance = [[AppOpenAdManager alloc] init];
  });
  return instance;
}

- (void)loadAd {
  // TODO: Implement loading an ad.
}

// Add this method to the .h file.
- (void)showAdIfAvailable {
  // TODO: Implement showing an ad.
}

- (BOOL)isAdAvailable {
  // Check if ad exists and can be shown.
  return self.appOpenAd != nil;
}

@end

विज्ञापन लोड करना

अगला चरण, loadAd() का तरीका भरना है.

Swift

private func loadAd() async {
  // Do not load ad if there is an unused ad or one is already loading.
  if isLoadingAd || isAdAvailable() {
    return
  }
  isLoadingAd = true

  do {
    appOpenAd = try await GADAppOpenAd.load(
      withAdUnitID: "/21775744923/example/app-open", request: GAMRequest())
  } catch {
    print("App open ad failed to load with error: \(error.localizedDescription)")
  }
  isLoadingAd = false
}

Objective-C

- (void)loadAd {
  // Do not load ad if there is an unused ad or one is already loading.
  if (self.isLoadingAd || [self isAdAvailable]) {
    return;
  }
  self.isLoadingAd = YES;

  [GADAppOpenAd loadWithAdUnitID:@"/21775744923/example/app-open"
                       request:[GAMRequest request]
             completionHandler:^(GADAppOpenAd *_Nullable appOpenAd, NSError *_Nullable error) {
               self.isLoadingAd = NO;
               if (error) {
                 NSLog(@"Failed to load app open ad: %@", error);
                 return;
               }
               self.appOpenAd = appOpenAd;
             }];
}

विज्ञापन दिखाना

अगला चरण, showAdIfAvailable() का तरीका भरना है. अगर कोई विज्ञापन उपलब्ध नहीं है, तो यह तरीका विज्ञापन लोड करने की कोशिश करता है.

Swift

func showAdIfAvailable() {
  // If the app open ad is already showing, do not show the ad again.
  guard !isShowingAd else { return }

  // If the app open ad is not available yet but is supposed to show, load
  // a new ad.
  if !isAdAvailable() {
    Task {
      await loadAd()
    }
    return
  }

  if let ad = appOpenAd {
    isShowingAd = true
    ad.present(fromRootViewController: nil)
  }
}

Objective-C

- (void)showAdIfAvailable {
  // If the app open ad is already showing, do not show the ad again.
  if (self.isShowingAd) {
    return;
  }

  // If the app open ad is not available yet but is supposed to show, load a
  // new ad.
  if (![self isAdAvailable]) {
    [self loadAd];
    return;
  }

  self.isShowingAd = YES;
  [self.appOpenAd presentFromRootViewController:nil];
}

ऐप्लिकेशन के फ़ोरग्राउंड इवेंट के दौरान विज्ञापन दिखाना

जब ऐप्लिकेशन चालू हो जाता है, तो विज्ञापन दिखाने के लिए showAdIfAvailable() को कॉल करें. अगर कोई विज्ञापन उपलब्ध नहीं है, तो नया विज्ञापन लोड करें.

Swift

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
  // ...

  func applicationDidBecomeActive(_ application: UIApplication) {
    // Show the app open ad when the app is foregrounded.
    AppOpenAdManager.shared.showAdIfAvailable()
  }
}

Objective-C

@implementation AppDelegate
// ...

- (void) applicationDidBecomeActive:(UIApplication *)application {
  // Show the app open ad when the app is foregrounded.
  [AppOpenAdManager.sharedInstance showAdIfAvailable];
}

@end

प्रज़ेंटेशन कॉलबैक मैनेज करना

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

अपनी AppOpenAdManager क्लास में, ये चीज़ें जोड़ें:

Swift

class AppOpenAdManager: NSObject, GADFullScreenContentDelegate {
  // ...

  private func loadAd() async {
    // Do not load ad if there is an unused ad or one is already loading.
    if isLoadingAd || isAdAvailable() {
      return
    }
    isLoadingAd = true

    do {
      appOpenAd = try await GADAppOpenAd.load(
        withAdUnitID: "/21775744923/example/app-open", request: GAMRequest())
      appOpenAd?.fullScreenContentDelegate = self
    } catch {
      print("App open ad failed to load with error: \(error.localizedDescription)")
    }
    isLoadingAd = false
  }

  // ...

  // MARK: - GADFullScreenContentDelegate methods

  func adWillPresentFullScreenContent(_ ad: GADFullScreenPresentingAd) {
    print("App open ad will be presented.")
  }

  func adDidDismissFullScreenContent(_ ad: GADFullScreenPresentingAd) {
    appOpenAd = nil
    isShowingAd = false
    // Reload an ad.
    Task {
      await loadAd()
    }
  }

  func ad(
    _ ad: GADFullScreenPresentingAd,
    didFailToPresentFullScreenContentWithError error: Error
  ) {
    appOpenAd = nil
    isShowingAd = false
    // Reload an ad.
    Task {
      await loadAd()
    }
  }
}

Objective-C

@interface AppOpenAdManager () <GADFullScreenContentDelegate>
@property(nonatomic, strong) GADAppOpenAd *appOpenAd
@property(nonatomic, assign) BOOL isLoadingAd;
@property(nonatomic, assign) BOOL isShowingAd;

@end

@implementation AppOpenAdManager

// ...

- (void)loadAd {
  // Do not load ad if there is an unused ad or one is already loading.
  if (self.isLoadingAd || [self isAdAvailable]) {
    return;
  }
  self.isLoadingAd = YES;

  [GADAppOpenAd loadWithAdUnitID:@"/21775744923/example/app-open"
                       request:[GAMRequest request]
             completionHandler:^(GADAppOpenAd *_Nullable appOpenAd, NSError *_Nullable error) {
              self.isLoadingAd = NO;
               if (error) {
                 NSLog(@"Failed to load app open ad: %@", error);
                 return;
               }
               self.appOpenAd = appOpenAd;
               self.appOpenAd.fullScreenContentDelegate = self;
             }];
}

- (BOOL)isAdAvailable {
  // Check if ad exists and can be shown.
  return self.appOpenAd != nil;
}

// ...

#pragma mark - GADFullScreenContentDelegate methods

- (void)adWillPresentFullScreenContent:(nonnull id<GADFullScreenPresentingAd>)ad {
  NSLog(@"App open ad is will be presented.");
}

- (void)adDidDismissFullScreenContent:(nonnull id<GADFullScreenPresentingAd>)ad {
  self.appOpenAd = nil;
  self.isShowingAd = NO;
  // Reload an ad.
  [self loadAd];
}

- (void)ad:(nonnull id<GADFullScreenPresentingAd>)ad
    didFailToPresentFullScreenContentWithError:(nonnull NSError *)error {
  self.appOpenAd = nil;
  self.isShowingAd = NO;
  // Reload an ad.
  [self loadAd];
}

@end

विज्ञापन की समयसीमा खत्म होने पर क्या होगा

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

अपने AppOpenAdManager में, loadTime नाम की Date प्रॉपर्टी जोड़ें और विज्ञापन लोड होने पर प्रॉपर्टी सेट करें. इसके बाद, एक ऐसा तरीका जोड़ा जा सकता है जो true दिखाए, अगर आपके विज्ञापन के लोड होने के बाद, तय किए गए घंटों से कम समय बीत चुका हो. विज्ञापन दिखाने से पहले, पक्का करें कि आपने विज्ञापन रेफ़रंस की पुष्टि कर ली है.

Swift

class AppOpenAdManager: NSObject, GADFullScreenContentDelegate {
  var appOpenAd: GADAppOpenAd?
  var isLoadingAd = false.
  var isShowingAd = false
  var loadTime: Date?
  let fourHoursInSeconds = TimeInterval(3600 * 4)

  // ...

  private func loadAd() async {
    // Do not load ad if there is an unused ad or one is already loading.
    if isLoadingAd || isAdAvailable() {
      return
    }
    isLoadingAd = true

    do {
      appOpenAd = try await GADAppOpenAd.load(
        withAdUnitID: "/21775744923/example/app-open", request: GAMRequest())
      appOpenAd?.fullScreenContentDelegate = self
      loadTime = Date()
    } catch {
      print("App open ad failed to load with error: \(error.localizedDescription)")
    }
    isLoadingAd = false
  }

  private func wasLoadTimeLessThanFourHoursAgo() -> Bool {
    guard let loadTime = loadTime else { return false }
    // Check if ad was loaded more than four hours ago.
    return Date().timeIntervalSince(loadTime) < fourHoursInSeconds
  }

  private func isAdAvailable() -> Bool {
    // Check if ad exists and can be shown.
    return appOpenAd != nil && wasLoadTimeLessThanFourHoursAgo()
  }
}

Objective-C

static NSTimeInterval const fourHoursInSeconds = 3600 * 4;

@interface AppOpenAdManager () <GADFullScreenContentDelegate>
@property(nonatomic, strong) GADAppOpenAd *appOpenAd
@property(nonatomic, assign) BOOL isLoadingAd;
@property(nonatomic, assign) BOOL isShowingAd;
@property(weak, nonatomic) NSDate *loadTime;

@end

@implementation AppOpenAdManager

// ...

- (void)loadAd {
  // Do not load ad if there is an unused ad or one is already loading.
  if (self.isLoadingAd || [self isAdAvailable]) {
    return;
  }
  self.isLoadingAd = YES;

  [GADAppOpenAd loadWithAdUnitID:@"/21775744923/example/app-open"
                       request:[GAMRequest request]
             completionHandler:^(GADAppOpenAd *_Nullable appOpenAd, NSError *_Nullable error) {
              self.isLoadingAd = NO;
               if (error) {
                 NSLog(@"Failed to load app open ad: %@", error);
                 return;
               }
               self.appOpenAd = appOpenAd;
               self.appOpenAd.fullScreenContentDelegate = self;
               self.loadTime = [NSDate date];
             }];
}

- (BOOL)wasLoadTimeLessThanFourHoursAgo {
  // Check if ad was loaded more than four hours ago.
  return [[NSDate Date] timeIntervalSinceDate:self.loadTime] < fourHoursInSeconds;
}

- (BOOL)isAdAvailable {
  // Check if ad exists and can be shown.
  return self.appOpenAd != nil && [self wasLoadTimeLessThanFourHoursAgo];
}

@end

कोल्ड स्टार्ट और लोडिंग स्क्रीन

दस्तावेज़ में यह माना गया है कि आप ऐप्लिकेशन खोलने पर दिखने वाले विज्ञापन सिर्फ़ तब दिखाते हैं, जब उपयोगकर्ता आपके ऐप्लिकेशन को मेमोरी में निलंबित होने के बाद फ़ोरग्राउंड में लाते हैं. "कोल्ड स्टार्ट" तब होते हैं, जब आपका ऐप्लिकेशन लॉन्च किया जाता है, लेकिन उसे पहले मेमोरी में निलंबित नहीं किया गया था.

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

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

सबसे सही तरीके

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

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

GitHub पर पूरा उदाहरण

Swift Objective-C

अगले चरण

उपयोगकर्ता की निजता के बारे में ज़्यादा जानें.