App-Start-Anzeigen

Plattform auswählen:Android iOS Unity Flutter

App-Start-Anzeigen sind ein spezielles Anzeigenformat für Publisher, die die Ladebildschirme ihrer Apps monetarisieren möchten. App-Start-Anzeigen können jederzeit geschlossen werden. Sie werden eingeblendet, wenn Nutzer Ihre App in den Vordergrund holen.

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

• Führen Sie die Schritte im Startleitfaden aus.
• Unity-Plug-in 7.1.0 oder höher.

Immer Testanzeigen verwenden

Der folgende Beispielcode enthält eine Anzeigenblock-ID, mit der Sie Testanzeigen anfordern können. Sie wurde speziell konfiguriert, um für jede Anfrage Testanzeigen anstelle von Produktionsanzeigen zurückzugeben. Daher ist die Verwendung sicher.

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 jedoch explizit als Testgerät konfigurieren.

Android

ca-app-pub-3940256099942544/9257395921

iOS

ca-app-pub-3940256099942544/5575463023

Implementierung

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

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

Hilfsklasse 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 zu erfassen.

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 the Google Mobile Ads SDK.
        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

App-Start-Anzeigen werden mit der statischen Methode Load() in der 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 Completion-Handler bereitgestellt. Das folgende Beispiel zeigt, wie Sie eine AppOpenAd laden.

 // 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);
          });
  }

Warnung :Es wird dringend davon abgeraten, zu versuchen, eine neue Anzeige über den Abschlussblock der Anzeigenanfrage zu laden, wenn das Laden einer Anzeige fehlgeschlagen ist. Wenn Sie eine Anzeige aus dem Block für den Abschluss der Anzeigenanfrage laden müssen, begrenzen Sie die Wiederholungsversuche, um kontinuierliche fehlgeschlagene Anzeigenanfragen in Situationen wie einer eingeschränkten Netzwerkverbindung zu vermeiden.

Auf App-Start-Anzeigen-Ereignisse warten

Um das Verhalten Ihrer Anzeige weiter anzupassen, können Sie eine Reihe von Ereignissen im Lebenszyklus der Anzeige nutzen, z. B. Öffnen und Schließen. Sie können auf diese Ereignisse warten, indem Sie einen Delegaten registrieren, 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

Wichtig: App-Start-Anzeigen laufen nach vier Stunden ab. Anzeigen, die mehr als vier Stunden nach dem Zeitpunkt der Anfrage gerendert werden, sind nicht länger gültig und erzielen möglicherweise keine Einnahmen.

Fügen Sie der 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.

Bei App-Start-Anzeigen tritt nach 4 Stunden eine Zeitüberschreitung auf. Speichern Sie die Ladezeit im Cache in der Variablen _expireTime.

// 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 die Property 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

Mit AppStateEventNotifier können Sie Ereignisse im Vorder- und Hintergrund der Anwendung erfassen. Diese Klasse löst das AppStateChanged-Ereignis 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 IsAdAvailable gleich true ist, rufen wir ShowAppOpenAd() auf, um die Anzeige zu präsentieren.

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 präsentieren

Rufen Sie zum Ausliefern einer geladenen App-Start-Anzeige die Methode Show() für die AppOpenAd-Instanz auf. Anzeigen können nur einmal pro Seitenaufruf ausgeliefert werden. Verwenden Sie die Methode CanShowAd(), um zu prüfen, ob die Anzeige ausgeliefert werden kann.

Hinweis :App-Start-Anzeigen sollten während natürlicher Pausen im Ablauf einer App eingeblendet werden, z. B. zwischen den Levels eines Spiels oder nachdem der Nutzer eine Aufgabe abgeschlossen hat.

/// <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 einem AppOpenAd fertig sind, rufen Sie die Methode Destroy() auf, bevor Sie die Referenz darauf löschen:

appOpenAd.Destroy();

Dadurch wird dem Plug-in mitgeteilt, dass das Objekt nicht mehr verwendet wird und der von ihm belegte Speicherplatz 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-Open-Anzeige anfordern möchten, müssen Sie ein neues AppOpenAd-Objekt erstellen.

Um eine App-Start-Anzeige für die nächste Impression vorzubereiten, laden Sie sie vorab, 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

Bisher wird in der Dokumentation davon ausgegangen, dass Sie App-Start-Anzeigen nur einblenden, wenn Nutzer Ihre App in den Vordergrund holen, nachdem sie im Arbeitsspeicher angehalten wurde. Von einem „Kaltstart“ spricht man, wenn Ihre App gestartet wird, aber nicht zuvor im Arbeitsspeicher angehalten wurde.

Ein Beispiel für einen Kaltstart ist, wenn ein Nutzer Ihre App zum ersten Mal öffnet. Bei Kaltstarts ist keine zuvor geladene App-Start-Anzeige verfügbar, 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 kurzzeitig verwenden können, bevor sie von einer Anzeige überrascht werden, die nicht zum Kontext passt. 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 wird dann nur auf dem Ladebildschirm eingeblendet. Wenn Ihre App vollständig geladen wurde und der Nutzer zum Hauptinhalt Ihrer App weitergeleitet wurde, darf die Anzeige nicht mehr präsentiert werden.

Wichtiger Hinweis :Damit App-Assets weiterhin geladen werden, während die App-Start-Anzeige eingeblendet wird, müssen Sie Assets immer in einem Hintergrundthread laden.

Best Practices

Mit App-Start-Anzeigen können Sie den Ladebildschirm Ihrer App monetarisieren, wenn die App zum ersten Mal gestartet wird und wenn Nutzer zwischen Apps wechseln. Damit Ihre Nutzer Ihre App gerne verwenden, sollten Sie die folgenden Best Practices beachten.

• Blenden Sie die erste App-Start-Anzeige ein, nachdem die Nutzer Ihre App einige Male verwendet haben.
• Blenden Sie App-Start-Anzeigen ein, wenn Ihre Nutzer ansonsten darauf warten müssten, dass Ihre App geladen wird.
• Wenn sich die App-Start-Anzeige auf einem Ladebildschirm befindet und der Ladevorgang abgeschlossen ist, bevor die Anzeige beendet wird, beenden Sie den Ladebildschirm im OnAdDidDismissFullScreenContent-Ereignishandler.
• Auf der iOS-Plattform wird durch AppStateEventNotifier eine AppStateEventClient GameObject instanziiert. Dieses GameObject ist erforderlich, damit Ereignisse ausgelöst werden. Sie dürfen es also nicht zerstören. Ereignisse werden nicht mehr ausgelöst, wenn das GameObject zerstört wird.

Zusätzliche Ressourcen

• HelloWorld-Beispiel: Eine minimale Implementierung aller Anzeigenformate.