App-Start-Anzeigen

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

Bei App-Start-Anzeigen wird automatisch ein kleiner Markenbereich eingeblendet, damit Nutzer wissen, dass sie sich in Ihrer App befinden. Hier sehen Sie ein Beispiel für eine App-Start-Anzeige:

Voraussetzungen

• Arbeiten Sie den Startleitfaden durch.
• Unity-Plug-in 7.1.0 oder höher

Immer mit Testanzeigen testen

Der folgende Beispielcode enthält eine Anzeigenblock-ID, mit der Sie Testanzeigen anfordern können. Es wurde speziell so konfiguriert, dass bei jeder Anfrage Testanzeigen statt Produktionsanzeigen zurückgegeben werden. Die Verwendung ist daher sicher.

Nachdem Sie jedoch eine App in derAd Manager -Weboberfläche registriert und eigene Anzeigenblock-IDs zur Verwendung in Ihrer App erstellt haben, müssen Sie Ihr Gerät während der Entwicklung explizit als Testgerät konfigurieren.

/6499/example/app-open

Implementierung

Die wichtigsten Schritte zur Einbindung von App-Start-Anzeigen sind:

1. Dienstprogrammklasse erstellen
2. App-Start-Anzeige laden
3. Ereignisse bei App-Start-Anzeigen erfassen
4. Ablauf der Anzeige berücksichtigen
5. App-Statusereignisse überwachen
6. App-Start-Anzeige einblenden
7. App-Start-Anzeige bereinigen
8. Nächste App-Start-Anzeige vorab laden

Dienstprogrammklasse 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 verfolgen.

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
{

    // This ad unit is configured to always serve test ads.
    private string _adUnitId = "/6499/example/app-open";

    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

Das Laden einer App-Start-Anzeige erfolgt mit der statischen Load()-Methode aus der Klasse AppOpenAd. Die Lademethode erfordert eine Anzeigenblock-ID, ein AdManagerAdRequest-Objekt und einen Abschluss-Handler, der aufgerufen wird, wenn das Laden der Anzeigen erfolgreich ist oder fehlschlägt. Das geladene AppOpenAd-Objekt wird im Abschluss-Handler als Parameter bereitgestellt. Das folgende Beispiel zeigt, wie ein AppOpenAd geladen wird.

  // This ad unit is configured to always serve test ads.
  private string _adUnitId = "/6499/example/app-open";

  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 AdManagerAdRequest();

      // 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 :Wir raten dringend davon ab, eine neue Anzeige über den Abschlussblock der Anzeigenanfrage zu laden, wenn eine Anzeige nicht geladen werden konnte. Wenn Sie eine Anzeige aus dem Block zum Abschluss von Anzeigenanfragen laden müssen, beschränken Sie die Wiederholungsversuche beim Laden von Anzeigen, um wiederholt fehlgeschlagene Anzeigenanfragen in Situationen wie eingeschränkter Netzwerkkonnektivität zu vermeiden.

Ereignisse bei App-Start-Anzeigen erfassen

Um das Verhalten Ihrer Anzeige weiter anzupassen, können Sie verschiedene Ereignisse im Lebenszyklus der Anzeige einbinden: Öffnen, Schließen usw. Sie können auf diese Ereignisse warten, indem Sie wie unten gezeigt einen Delegaten registrieren.

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 der Anzeige 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 mehr gültig und erzielen möglicherweise keine Einnahmen.

Damit keine abgelaufene Anzeige ausgeliefert wird, fügen Sie dem AppOpenAdController eine Methode hinzu, mit der geprüft wird, wie viel Zeit seit dem Laden der Anzeige vergangen ist. Überprüfen Sie dann mit dieser Methode, ob die Anzeige noch gültig ist.

Die App-Start-Anzeige hat ein Zeitlimit von 4 Stunden. Speichern Sie die Ladezeit 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 das Attribut IsAdAvailable, um mit _expireTime zu prüfen, ob die geladene Anzeige noch gültig ist.

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

App-Statusereignisse überwachen

Verwenden Sie AppStateEventNotifier, um auf Ereignisse im Vorder- und Hintergrund der Anwendung zu warten. Diese Klasse löst das AppStateChanged-Ereignis aus, wenn die Anwendung im Vordergrund oder Hintergrund ausgeführt wird.

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 der Status AppState.Foreground verarbeitet wird und IsAdAvailable den Wert true hat, wird ShowAppOpenAd() aufgerufen, um die Anzeige auszuliefern.

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 pro Ladevorgang nur einmal ausgeliefert werden. Mit der Methode CanShowAd() können Sie prüfen, ob die Anzeige zur Auslieferung bereit ist.

Hinweis :App-Start-Anzeigen sollten in natürlichen Pausen im Spielverlauf eingeblendet werden. Ein gutes Beispiel ist das 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 Ihren Verweis darauf löschen:

appOpenAd.Destroy();

Dadurch wird das Plug-in darüber informiert, dass das Objekt nicht mehr verwendet wird und der von ihm belegte Arbeitsspeicher zurückgefordert werden kann. Wenn diese Methode nicht aufgerufen wird, treten Speicherlecks auf.

Nächste App-Start-Anzeige vorab laden

AppOpenAd ist ein Objekt zur einmaligen Verwendung. Das bedeutet, dass das Objekt nicht noch einmal verwendet werden kann, sobald eine App-Start-Anzeige eingeblendet wird. Wenn Sie eine weitere App-Start-Anzeige anfordern möchten, müssen Sie ein neues AppOpenAd-Objekt erstellen.

Um eine App-Start-Anzeige auf die nächste mögliche Impression vorzubereiten, laden Sie die App-Start-Anzeige 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

In der Dokumentation wird bisher davon ausgegangen, dass App-Start-Anzeigen nur dann ausgeliefert werden, wenn Nutzer Ihre App im Vordergrund platzieren, wenn sie im Arbeitsspeicher gesperrt ist. „Kaltstarts“ treten auf, wenn Ihre App gestartet, aber noch nicht im Arbeitsspeicher angehalten wurde.

Ein Beispiel für einen Kaltstart liegt vor, wenn ein Nutzer deine App zum ersten Mal öffnet. Bei Kaltstarts ist keine bereits geladene App-Start-Anzeige verfügbar, die sofort ausgeliefert werden kann. Die Verzögerung zwischen der Anfrage einer Anzeige und dem Erhalt einer Anzeige kann dazu führen, dass Nutzer Ihre App kurz verwenden können, bevor sie von einer Anzeige außerhalb des Kontexts überrascht werden. Dies sollte vermieden werden, da es eine schlechte User Experience darstellt.

App-Start-Anzeigen werden bei Kaltstarts am besten mit einem Ladebildschirm verwendet, um Ihre Spiele- oder App-Assets zu laden und die Anzeige nur auf dem Ladebildschirm zu präsentieren. Wenn der Ladevorgang Ihrer App abgeschlossen ist und der Nutzer zum Hauptinhalt Ihrer App weitergeleitet wurde, sollten Sie die Anzeige nicht einblenden.

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

Best Practices

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

• Präsentieren Sie Ihre erste App-Start-Anzeige, nachdem Nutzer Ihre App einige Male verwendet haben.
• Präsentieren Sie App-Start-Anzeigen zu Zeiten, in denen Nutzer andernfalls auf das Laden Ihrer App warten würden.
• Wenn sich unter der App-Start-Anzeige ein Ladebildschirm befindet und der Ladevorgang abgeschlossen ist, bevor die Anzeige geschlossen wird, schließen Sie den Ladebildschirm im Event-Handler OnAdDidDismissFullScreenContent.
• Auf der iOS-Plattform instanziiert AppStateEventNotifier eine AppStateEventClient GameObject. Dieses GameObject ist erforderlich, damit Ereignisse ausgelöst werden. Du solltest sie also nicht löschen. Wenn GameObject gelöscht wird, werden keine Ereignisse mehr ausgelöst.

Weitere Ressourcen

• HelloWorld-Beispiel: Eine minimale Implementierung aller Anzeigenformate.