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

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

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

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

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

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

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

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

• /21775744923/example/app-open

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

लागू करना

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

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 = '/21775744923/example/app-open';
  
  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 क्लास पर loadWithAdManagerAdRequest तरीके का इस्तेमाल किया जाता है. लोड करने के तरीके के लिए, विज्ञापन यूनिट आईडी, ऑरिएंटेशन मोड, AdManagerAdRequest ऑब्जेक्ट, और पूरा होने के हैंडलर की ज़रूरत होती है. यह हैंडलर, विज्ञापन लोड होने या न होने पर कॉल किया जाता है. लोड किए गए AppOpenAd ऑब्जेक्ट को, पूरा होने के हैंडलर में पैरामीटर के तौर पर दिया जाता है. यहां दिए गए उदाहरण में, AppOpenAd को लोड करने का तरीका बताया गया है.

public class AppOpenAdManager {
  ...

  /// Load an AppOpenAd.
  void loadAd() {
    AppOpenAd.loadWithAdManagerAdRequest(
      adUnitId: adUnitId,
      adManagerAdRequest: AdManagerAdRequest(),
      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.loadWithAdManagerAdRequest(
      adUnitId: adUnitId,
      orientation: AppOpenAd.orientationPortrait,
      adManagerAdRequest: AdManagerAdRequest(),
      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 इवेंट हैंडलर में लोड होने वाली स्क्रीन को बंद किया जा सकता है.