App-Start-Anzeigen

App-Start-Anzeigen sind ein spezielles Anzeigenformat für Publisher, die mit den Ladebildschirmen ihrer App Einnahmen erzielen möchten. App-Start-Anzeigen können jederzeit geschlossen werden und werden eingeblendet, wenn Nutzer Ihre App in den Vordergrund bringen.

Bei App-Start-Anzeigen ist automatisch das Branding Ihrer App zu sehen, damit die Nutzer wissen, dass sie sich in Ihrer App befinden. Hier ist ein Beispiel für eine App-Start-Anzeige:

Vorbereitung

Bevor Sie fortfahren, führen Sie die folgenden Schritte aus:

Immer mit Testanzeigen testen

Der folgende Beispielcode enthält eine Anzeigenblock-ID, mit der Sie Testanzeigen anfordern können. Sie ist speziell so konfiguriert, dass für jede Anfrage Testanzeigen anstelle von Produktionsanzeigen zurückgegeben werden. Sie kann also bedenkenlos verwendet werden.

Nachdem Sie eine App in der AdMob-Weboberfläche registriert und eigene Anzeigenblock-IDs für die Verwendung in Ihrer App erstellt haben, sollten Sie Ihr Gerät während der Entwicklung explizit als Testgerät konfigurieren.

Android

ca-app-pub-3940256099942544/1033173712

iOS

ca-app-pub-3940256099942544/4411468910

Implementierung

Die wichtigsten Schritte zum Einbinden von App-Start-Anzeigen sind:

  1. Utility-Klasse erstellen
  2. App-Start-Anzeige laden
  3. Auf Ereignisse von App-Start-Anzeigen warten
  4. Ablauf von Anzeigen berücksichtigen
  5. Auf App-Statusereignisse warten
  6. App-Start-Anzeige einblenden
  7. App-Start-Anzeige bereinigen
  8. Nächste App-Start-Anzeige vorab laden

Utility-Klasse erstellen

Erstellen Sie eine neue Klasse mit dem Namen AppOpenAdController, um die Anzeige zu laden. Diese Klasse steuert eine Instanzvariable, um eine geladene Anzeige und die Anzeigenblock-ID für jede Plattform im Blick zu behalten.

using System;
using UnityEngine;
using GoogleMobileAds.Api;
using GoogleMobileAds.Common;

/// <summary>
/// Demonstrates how to use the Google Mobile Ads app open ad format.
/// </summary>
[AddComponentMenu("GoogleMobileAds/Samples/AppOpenAdController")]
public class AppOpenAdController : MonoBehaviour
{

    // These ad units are configured to always serve test ads.
#if UNITY_ANDROID
    private string _adUnitId = "ca-app-pub-3940256099942544/9257395921";
#elif UNITY_IPHONE
    string _adUnitId = "ca-app-pub-3940256099942544/5575463023";
#else
    private string _adUnitId = "unused";
#endif

    public bool IsAdAvailable
    {
        get
        {
            return _appOpenAd != null;
        }
    }

    public void Start()
    {
        // Initialize Google Mobile Ads Unity Plugin.
        MobileAds.Initialize((InitializationStatus initStatus) =>
        {
            // This callback is called once the MobileAds SDK is initialized.
        });
    }

    /// <summary>
    /// Loads the app open ad.
    /// </summary>
    public void LoadAppOpenAd()
    {
    }

    /// <summary>
    /// Shows the app open ad.
    /// </summary>
    public void ShowAppOpenAd()
    {
    }
}

App-Start-Anzeige laden

Eine App-Start-Anzeige wird mit der statischen Methode Load() für die Klasse AppOpenAd geladen. Für die Methode „load“ sind eine Anzeigenblock-ID, ein AdRequest-Objekt und ein Completion-Handler erforderlich, der aufgerufen wird, wenn das Laden der Anzeige erfolgreich ist oder fehlschlägt. Das geladene AppOpenAd-Objekt wird als Parameter im Abschluss-Handler bereitgestellt. Im folgenden Beispiel wird gezeigt, wie ein AppOpenAd geladen wird.


 // These ad units are configured to always serve test ads.
#if UNITY_ANDROID
   private string _adUnitId = "ca-app-pub-3940256099942544/9257395921";
#elif UNITY_IPHONE
   string _adUnitId = "ca-app-pub-3940256099942544/5575463023";
#else
  private string _adUnitId = "unused";
#endif

  private AppOpenAd appOpenAd;

  /// <summary>
  /// Loads the app open ad.
  /// </summary>
  public void LoadAppOpenAd()
  {
      // Clean up the old ad before loading a new one.
      if (appOpenAd != null)
      {
            appOpenAd.Destroy();
            appOpenAd = null;
      }

      Debug.Log("Loading the app open ad.");

      // Create our request used to load the ad.
      var adRequest = new AdRequest();

      // send the request to load the ad.
      AppOpenAd.Load(_adUnitId, adRequest,
          (AppOpenAd ad, LoadAdError error) =>
          {
              // if error is not null, the load request failed.
              if (error != null || ad == null)
              {
                  Debug.LogError("app open ad failed to load an ad " +
                                 "with error : " + error);
                  return;
              }

              Debug.Log("App open ad loaded with response : "
                        + ad.GetResponseInfo());

              appOpenAd = ad;
              RegisterEventHandlers(ad);
          });
  }

Auf Ereignisse von App-Start-Anzeigen warten

Wenn Sie das Verhalten Ihrer Anzeige weiter anpassen möchten, können Sie eine Reihe von Ereignissen im Lebenszyklus der Anzeige nutzen, z. B. das Öffnen und Schließen. Registrieren Sie einen Bevollmächtigten, um diese Ereignisse zu überwachen, wie unten gezeigt.

private void RegisterEventHandlers(AppOpenAd ad)
{
    // Raised when the ad is estimated to have earned money.
    ad.OnAdPaid += (AdValue adValue) =>
    {
        Debug.Log(String.Format("App open ad paid {0} {1}.",
            adValue.Value,
            adValue.CurrencyCode));
    };
    // Raised when an impression is recorded for an ad.
    ad.OnAdImpressionRecorded += () =>
    {
        Debug.Log("App open ad recorded an impression.");
    };
    // Raised when a click is recorded for an ad.
    ad.OnAdClicked += () =>
    {
        Debug.Log("App open ad was clicked.");
    };
    // Raised when an ad opened full screen content.
    ad.OnAdFullScreenContentOpened += () =>
    {
        Debug.Log("App open ad full screen content opened.");
    };
    // Raised when the ad closed full screen content.
    ad.OnAdFullScreenContentClosed += () =>
    {
        Debug.Log("App open ad full screen content closed.");
    };
    // Raised when the ad failed to open full screen content.
    ad.OnAdFullScreenContentFailed += (AdError error) =>
    {
        Debug.LogError("App open ad failed to open full screen content " +
                       "with error : " + error);
    };
}

Ablauf von Anzeigen berücksichtigen

Fügen Sie dem AppOpenAdController eine Methode hinzu, mit der geprüft wird, wie lange es her ist, dass Ihre Anzeige geladen wurde, damit keine abgelaufene Anzeige ausgeliefert wird. Prüfen Sie dann mit dieser Methode, ob die Anzeige noch gültig ist.

Für App-Start-Anzeigen gilt ein Zeitlimit von 4 Stunden. Speichern Sie die Ladezeit in der Variablen _expireTime im Cache.

// send the request to load the ad.
AppOpenAd.Load(_adUnitId, adRequest,
    (AppOpenAd ad, LoadAdError error) =>
    {
        // If the operation failed, an error is returned.
        if (error != null || ad == null)
        {
            Debug.LogError("App open ad failed to load an ad with error : " +
                            error);
            return;
        }

        // If the operation completed successfully, no error is returned.
        Debug.Log("App open ad loaded with response : " + ad.GetResponseInfo());

        // App open ads can be preloaded for up to 4 hours.
        _expireTime = DateTime.Now + TimeSpan.FromHours(4);

        _appOpenAd = ad;
    });

Aktualisieren Sie das Attribut IsAdAvailable, um _expireTime zu prüfen und zu bestätigen, dass die geladene Anzeige noch gültig ist.

public bool IsAdAvailable
{
    get
    {
        return _appOpenAd != null
               && _appOpenAd.IsLoaded()
               && DateTime.Now < _expireTime;
    }
}

Auf App-Statusereignisse warten

Verwenden Sie AppStateEventNotifier, um Ereignisse im Vordergrund und im Hintergrund der Anwendung zu beobachten. Diese Klasse löst das Ereignis AppStateChanged aus, wenn die Anwendung in den Vorder- oder Hintergrund wechselt.

private void Awake()
{
    // Use the AppStateEventNotifier to listen to application open/close events.
    // This is used to launch the loaded ad when we open the app.
    AppStateEventNotifier.AppStateChanged += OnAppStateChanged;
}

private void OnDestroy()
{
    // Always unlisten to events when complete.
    AppStateEventNotifier.AppStateChanged -= OnAppStateChanged;
}

Wenn wir den Status AppState.Foreground verarbeiten und der IsAdAvailable true ist, rufen wir ShowAppOpenAd() auf, um die Anzeige einzublenden.

private void OnAppStateChanged(AppState state)
{
    Debug.Log("App State changed to : "+ state);

    // if the app is Foregrounded and the ad is available, show it.
    if (state == AppState.Foreground)
    {
        if (IsAdAvailable)
        {
            ShowAppOpenAd();
        }
    }
}

App-Start-Anzeige einblenden

Wenn Sie eine geladene App-Start-Anzeige präsentieren möchten, rufen Sie die Methode Show() für die Instanz AppOpenAd auf. Anzeigen können nur einmal pro Ladevorgang ausgeliefert werden. Verwenden Sie die Methode CanShowAd(), um zu prüfen, ob die Anzeige bereit für die Auslieferung ist.

/// <summary>
/// Shows the app open ad.
/// </summary>
public void ShowAppOpenAd()
{
    if (appOpenAd != null && appOpenAd.CanShowAd())
    {
        Debug.Log("Showing app open ad.");
        appOpenAd.Show();
    }
    else
    {
        Debug.LogError("App open ad is not ready yet.");
    }
}

App-Start-Anzeige bereinigen

Wenn Sie mit einer AppOpenAd fertig sind, rufen Sie die Methode Destroy() auf, bevor Sie die entsprechende Referenz löschen:

appOpenAd.Destroy();

Dadurch wird das Plug-in darüber informiert, dass das Objekt nicht mehr verwendet wird und der belegte Arbeitsspeicher freigegeben werden kann. Wenn diese Methode nicht aufgerufen wird, kommt es zu Speicherlecks.

Nächste App-Start-Anzeige vorab laden

AppOpenAd ist ein Einmalobjekt. Das bedeutet, dass das Objekt nicht noch einmal verwendet werden kann, nachdem eine Anzeige beim Öffnen der App ausgeliefert wurde. Wenn Sie eine weitere App-Start-Anzeige anfordern möchten, müssen Sie ein neues AppOpenAd-Objekt erstellen.

Wenn Sie eine App-Start-Anzeige für die nächste Impressionsmöglichkeit vorbereiten möchten, laden Sie die App-Start-Anzeige vor, sobald das Anzeigenereignis OnAdFullScreenContentClosed oder OnAdFullScreenContentFailed ausgelöst wird.

private void RegisterReloadHandler(AppOpenAd ad)
{
    ...
    // Raised when the ad closed full screen content.
    ad.OnAdFullScreenContentClosed += ()
    {
        Debug.Log("App open ad full screen content closed.");

        // Reload the ad so that we can show another as soon as possible.
        LoadAppOpenAd();
    };
    // Raised when the ad failed to open full screen content.
    ad.OnAdFullScreenContentFailed += (AdError error) =>
    {
        Debug.LogError("App open ad failed to open full screen content " +
                       "with error : " + error);

        // Reload the ad so that we can show another as soon as possible.
        LoadAppOpenAd();
    };
}

Kaltstarts und Ladebildschirme

In der bisherigen Dokumentation wird davon ausgegangen, dass Sie App-Start-Anzeigen nur dann einblenden, wenn Nutzer Ihre App in den Vordergrund holen, während sie im Arbeitsspeicher angehalten ist. „Kaltstarts“ treten auf, wenn Ihre App gestartet wird, aber zuvor nicht im Arbeitsspeicher angehalten wurde.

Ein Beispiel für einen Kaltstart ist, wenn ein Nutzer Ihre App zum ersten Mal öffnet. Bei einem Kaltstart ist keine zuvor geladene App-Start-Anzeige vorhanden, die sofort ausgeliefert werden kann. Die Verzögerung zwischen dem Anfordern einer Anzeige und dem Erhalt einer Anzeige kann dazu führen, dass Nutzer Ihre App kurz verwenden können, bevor sie von einer kontextfremden Anzeige überrascht werden. Dies sollte vermieden werden, da es zu einer schlechten Nutzererfahrung führt.

Die bevorzugte Methode für App-Start-Anzeigen bei Kaltstarts ist die Verwendung eines Ladebildschirms zum Laden der Assets Ihres Spiels oder Ihrer App. Die Anzeige sollte nur auf dem Ladebildschirm eingeblendet werden. Wenn Ihre App vollständig geladen wurde und der Nutzer zum Hauptinhalt Ihrer App weitergeleitet wurde, sollte die Anzeige nicht mehr präsentiert werden.

Best Practices

Mit App-Start-Anzeigen können Sie den Ladebildschirm Ihrer App beim ersten Start und beim Wechsel zwischen Apps monetarisieren. Beachten Sie jedoch die folgenden Best Practices, damit Ihre Nutzer die App gern verwenden.

  • Blenden Sie die erste App-Start-Anzeige ein, nachdem die Nutzer Ihre App einige Male verwendet haben.
  • Präsentieren Sie App-Start-Anzeigen, während Nutzer darauf warten, dass die App geladen wird.
  • Wenn sich die App-Start-Anzeige auf einem Ladebildschirm befindet und der Ladevorgang abgeschlossen ist, bevor die Anzeige beendet wird, können Sie den Ladebildschirm mit dem Ereignis-Handler OnAdDidDismissFullScreenContent beenden.
  • Auf der iOS-Plattform wird durch AppStateEventNotifier ein AppStateEventClient GameObject instanziiert. Dieses GameObject ist erforderlich, damit Ereignisse ausgelöst werden. Sie dürfen es also nicht löschen. Ereignisse werden nicht mehr ausgelöst, wenn das GameObject gelöscht wird.

Zusätzliche Ressourcen