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

प्लैटफ़ॉर्म चुनें: Android iOS Unity Flutter

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

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

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

  • Flutter प्लगिन 0.13.6 या इसके बाद का वर्शन.
  • शुरू करें पर क्लिक करें. आपके Flutter ऐप्लिकेशन में, Google Mobile Ads Flutter प्लगिन पहले से इंपोर्ट किया गया होना चाहिए.

हमेशा टेस्ट विज्ञापनों का इस्तेमाल करके टेस्ट करें

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

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

Android

ca-app-pub-3940256099942544/9257395921

iOS

ca-app-pub-3940256099942544/5575463023

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

लागू करना

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

  1. ऐसी यूटिलिटी क्लास बनाएं जो विज्ञापन को दिखाने से पहले लोड कर दे.
  2. विज्ञापन लोड करें.
  3. कॉलबैक के लिए रजिस्टर करता है और विज्ञापन दिखाता है.
  4. फ़ोरग्राउंडिंग इवेंट के दौरान विज्ञापन दिखाने के लिए, AppStateEventNotifier.appStateStream की सदस्यता लें.

कोई यूटिलिटी क्लास बनाना

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

import 'package:google_mobile_ads/google_mobile_ads.dart';
import 'dart:io' show Platform;

class AppOpenAdManager {
  
  String adUnitId = Platform.isAndroid
    ? 'ca-app-pub-3940256099942544/9257395921'
    : 'ca-app-pub-3940256099942544/5575463023';
  
  AppOpenAd? _appOpenAd;
  bool _isShowingAd = false;

  /// Load an AppOpenAd.
  void loadAd() {
    // We will implement this below.
  }

  /// Whether an ad is available to be shown.
  bool get isAdAvailable {
    return _appOpenAd != null;
  }
}

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

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

विज्ञापन लोड करने के लिए, AppOpenAd क्लास में load तरीके का इस्तेमाल किया जाता है. लोड करने के तरीके के लिए, विज्ञापन यूनिट आईडी, ओरिएंटेशन मोड, AdRequest ऑब्जेक्ट, और पूरा होने वाला हैंडलर ज़रूरी होता है. विज्ञापन लोड होने पर या लोड न होने पर, इसे कॉल किया जाता है. लोड किया गया AppOpenAd ऑब्जेक्ट, कंप्लीशन हैंडलर में पैरामीटर के तौर पर दिया जाता है. यहां दिए गए उदाहरण में, AppOpenAd को लोड करने का तरीका बताया गया है.

public class AppOpenAdManager {
  ...

  /// Load an AppOpenAd.
  void loadAd() {
    AppOpenAd.load(
      adUnitId: adUnitId,
      adRequest: AdRequest(),
      adLoadCallback: AppOpenAdLoadCallback(
        onAdLoaded: (ad) {
          _appOpenAd = ad;
        },
        onAdFailedToLoad: (error) {
          print('AppOpenAd failed to load: $error');
          // Handle the error.
        },
      ),
    );
  }
}

विज्ञापन दिखाना और फ़ुलस्क्रीन कॉलबैक मैनेज करना

विज्ञापन दिखाने से पहले, आपको जिस विज्ञापन इवेंट के बारे में सूचना चाहिए उसके लिए FullScreenContentCallback रजिस्टर करें.

public class AppOpenAdManager {
  ...

  public void showAdIfAvailable() {
    if (!isAdAvailable) {
      print('Tried to show ad before available.');
      loadAd();
      return;
    }
    if (_isShowingAd) {
      print('Tried to show ad while already showing an ad.');
      return;
    }
    // Set the fullScreenContentCallback and show the ad.
    _appOpenAd!.fullScreenContentCallback = FullScreenContentCallback(
      onAdShowedFullScreenContent: (ad) {
        _isShowingAd = true;
        print('$ad onAdShowedFullScreenContent');
      },
      onAdFailedToShowFullScreenContent: (ad, error) {
        print('$ad onAdFailedToShowFullScreenContent: $error');
        _isShowingAd = false;
        ad.dispose();
        _appOpenAd = null;
      },
      onAdDismissedFullScreenContent: (ad) {
        print('$ad onAdDismissedFullScreenContent');
        _isShowingAd = false;
        ad.dispose();
        _appOpenAd = null;
        loadAd();
      },
    );
  }
}

अगर कोई व्यक्ति, ऐप्लिकेशन खोलने वाले विज्ञापन पर क्लिक करके आपके ऐप्लिकेशन से बाहर निकल जाता है और फिर वापस आता है, तो पक्का करें कि उसे ऐप्लिकेशन खोलने वाला कोई दूसरा विज्ञापन न दिखे.

ऐप्लिकेशन के फ़ोरग्राउंड में आने वाले इवेंट को मॉनिटर करने की अनुमति

ऐप्लिकेशन के फ़ोरग्राउंड होने के इवेंट की सूचना पाने के लिए, आपको AppStateEventNotifier.appStateStream की सदस्यता लेनी होगी और foreground इवेंट सुनने होंगे.

import 'package:app_open_example/app_open_ad_manager.dart';
import 'package:google_mobile_ads/google_mobile_ads.dart';

/// Listens for app foreground events and shows app open ads.
class AppLifecycleReactor {
  final AppOpenAdManager appOpenAdManager;

  AppLifecycleReactor({required this.appOpenAdManager});

  void listenToAppStateChanges() {
    AppStateEventNotifier.startListening();
    AppStateEventNotifier.appStateStream
        .forEach((state) => _onAppStateChanged(state));
  }

  void _onAppStateChanged(AppState appState) {
    // Try to show an app open ad if the app is being resumed and
    // we're not already showing an app open ad.
    if (appState == AppState.foreground) {
      appOpenAdManager.showAdIfAvailable();
    }
  }
}

अब AppLifecycleReactor को शुरू किया जा सकता है और ऐप्लिकेशन के लाइफ़साइकल में होने वाले बदलावों को सुना जा सकता है. उदाहरण के लिए, अपने होम पेज से:

import 'package:app_open_example/app_open_ad_manager.dart';
import 'package:flutter/material.dart';
import 'package:google_mobile_ads/google_mobile_ads.dart';

import 'app_lifecycle_reactor.dart';

void main() {
  WidgetsFlutterBinding.ensureInitialized();
  MobileAds.instance.initialize();
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'App Open Example',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: MyHomePage(title: 'App Open Demo Home Page'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  MyHomePage({Key? key, required this.title}) : super(key: key);

  final String title;

  @override
  _MyHomePageState createState() => _MyHomePageState();
}

/// Example home page for an app open ad.
class _MyHomePageState extends State<MyHomePage> {
  int _counter = 0;
  late AppLifecycleReactor _appLifecycleReactor;

  @override
  void initState() {
    super.initState();
    
    AppOpenAdManager appOpenAdManager = AppOpenAdManager()..loadAd();
    _appLifecycleReactor = AppLifecycleReactor(
      appOpenAdManager: appOpenAdManager);
  }

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

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

/// Utility class that manages loading and showing app open ads.
class AppOpenAdManager {
  ...
  
  /// Maximum duration allowed between loading and showing the ad.
  final Duration maxCacheDuration = Duration(hours: 4);

  /// Keep track of load time so we don't show an expired ad.
  DateTime? _appOpenLoadTime;
  
  ...

  /// Load an AppOpenAd.
  void loadAd() {
    AppOpenAd.load(
      adUnitId: adUnitId,
      orientation: AppOpenAd.orientationPortrait,
      adRequest: AdRequest(),
      adLoadCallback: AppOpenAdLoadCallback(
        onAdLoaded: (ad) {
          print('$ad loaded');
          _appOpenLoadTime = DateTime.now();
          _appOpenAd = ad;
        },
        onAdFailedToLoad: (error) {
          print('AppOpenAd failed to load: $error');
        },
      ),
    );
  }

  /// Shows the ad, if one exists and is not already being shown.
  ///
  /// If the previously cached ad has expired, this just loads and caches a
  /// new ad.
  void showAdIfAvailable() {
    if (!isAdAvailable) {
      print('Tried to show ad before available.');
      loadAd();
      return;
    }
    if (_isShowingAd) {
      print('Tried to show ad while already showing an ad.');
      return;
    }
    if (DateTime.now().subtract(maxCacheDuration).isAfter(_appOpenLoadTime!)) {
      print('Maximum cache duration exceeded. Loading another ad.');
      _appOpenAd!.dispose();
      _appOpenAd = null;
      loadAd();
      return;
    }
    // Set the fullScreenContentCallback and show the ad.
    _appOpenAd!.fullScreenContentCallback = FullScreenContentCallback(...);
    _appOpenAd!.show();
  }
}

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

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

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

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

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

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

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

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

ऐप्लिकेशन ओपन