App-Start-Anzeigen

App-Start-Anzeigen sind ein spezielles Anzeigenformat für Publisher, App-Ladebildschirme. App-Start-Anzeigen können jederzeit geschlossen werden. die eingeblendet werden, wenn Nutzer Ihre App im Vordergrund zeigen.

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

Vorbereitung

  • 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 zu testen. Es wurde speziell so konfiguriert, dass Testanzeigen zurückgegeben werden, Produktionsanzeigen für jede Anfrage erstellen, damit sie sicher verwendet werden können.

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

/21775744923/example/app-open

Implementierung

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

  1. Dienstprogrammklasse erstellen
  2. App-Start-Anzeige laden
  3. App-Start-Anzeigenereignisse erfassen
  4. Ablauf von Anzeigen berücksichtigen
  5. App-Statusereignisse überwachen
  6. App-Start-Anzeige einblenden
  7. App-Start-Anzeige bereinigen
  8. Next App-Start-Anzeige vorab laden

Dienstprogrammklasse erstellen

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

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 = "/21775744923/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 über die statische Methode Load() der Klasse AppOpenAd. Für die Lademethode ist eine Anzeigenblock-ID, eine AdManagerAdRequest-Objekt und einem Abschluss-Handler, der wird aufgerufen, wenn das Laden der Anzeige erfolgreich ist oder fehlschlägt. Das geladene AppOpenAd-Objekt ist als Parameter im Abschluss-Handler bereitgestellt. Das folgende Beispiel zeigt, um ein AppOpenAd zu laden.


  // This ad unit is configured to always serve test ads.
  private string _adUnitId = "/21775744923/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);
          });
  }

App-Start-Anzeigenereignisse erfassen

Zur weiteren Anpassung des Anzeigenverhaltens können Sie Ereignisse im Lebenszyklus der Anzeige zu sehen, z. B. das Öffnen oder Schließen. Registrieren Sie einen Delegate, um auf diese Ereignisse zu warten, 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

Um sicherzustellen, dass keine abgelaufenen Anzeigen geschaltet werden, fügen Sie eine Methode zum AppOpenAdController, mit dem geprüft wird, wie lange es her ist, dass Ihre Anzeige geladen wurde. Ü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 _expireTime zu prüfen und das geladene Objekt zu bestätigen. Anzeige noch gültig ist.

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

App-Statusereignisse überwachen

Mit dem AppStateEventNotifier können Sie Ereignisse im Vordergrund und Hintergrund der Anwendung beobachten. Diese Klasse löst das Ereignis AppStateChanged aus, wenn die Anwendung im Vordergrund oder im Hintergrund ist.

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 und IsAdAvailable verarbeitet werden, true ist, rufen wir ShowAppOpenAd() auf, um die Anzeige zu schalten.

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() auf der AppOpenAd-Instanz. Anzeigen können nur einmal pro Ladevorgang ausgeliefert werden. CanShowAd() verwenden um zu überprüfen, ob die Anzeige ausgeliefert werden kann.

/// <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, denken Sie daran, die Destroy() aufzurufen bevor Sie den Verweis darauf löschen:

appOpenAd.Destroy();

Dadurch wird das Plug-in darüber informiert, dass das Objekt nicht mehr verwendet wird, und den Arbeitsspeicher belegt, können zurückgefordert werden. Wenn diese Methode nicht aufgerufen wird, treten Speicherlecks auf.

Next App-Start-Anzeige vorab laden

AppOpenAd ist ein Objekt zur einmaligen Verwendung. Sobald eine App-Start-Anzeige zu sehen ist, Das Objekt kann nicht noch einmal verwendet werden. Um eine weitere App-Start-Anzeige anzufordern, müssen Sie ein neues AppOpenAd-Objekt erstellen.

Um eine App-Start-Anzeige auf die nächste Impression vorzubereiten, laden Sie die App-Start-Anzeige, sobald OnAdFullScreenContentClosed oder OnAdFullScreenContentFailed Anzeigenereignis wurde ausgelöst.

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 ausgeliefert werden, wenn Nutzer App im Vordergrund ausführen, wenn sie im Arbeitsspeicher ausgesetzt wird. „Kaltstarts“ treten auf, wenn Ihre App wurde gestartet, aber zuvor nicht im Arbeitsspeicher gesperrt.

Ein Beispiel für einen Kaltstart ist, wenn ein Nutzer Ihre App zum ersten Mal öffnet. Bei Kaltstarts gibt es keine bereits geladene App-Start-Anzeige, die sofort geschaltet werden. Die Verzögerung zwischen dem Anfordern und dem Empfangen einer Anzeige kann dazu führen, dass Nutzer Ihre App kurz nutzen können, bevor sie von einer nicht kontextbezogenen Anzeige überrascht werden. Dies sollte vermieden werden, schlechte User Experience ausmacht.

App-Start-Anzeigen werden bei Kaltstarts vorzugsweise mit einem Ladebildschirm eingesetzt. Ihre Spiel- oder App-Assets zu laden und die Anzeige nur Bildschirm. Wenn der Ladevorgang Ihrer App abgeschlossen ist und der Nutzer zur Hauptseite weitergeleitet wurde: App-Content enthält, wird die Anzeige nicht geschaltet.

Best Practices

Mit App-Start-Anzeigen können Sie den Ladebildschirm der App monetarisieren, wenn die App das erste Mal verwendet wird. bei App-Starts und beim Wechsel zwischen Apps. Folgendes sollte jedoch am besten damit die Nutzer deine App gern verwenden.

  • Blenden Sie die erste App-Start-Anzeige ein, nachdem die Nutzer Ihre App einige Male verwendet haben.
  • App-Start-Anzeigen zu Zeiten ausliefern, in denen die Nutzer sonst warten würden um Ihre App zu laden.
  • Wenn unter der App-Start-Anzeige und dem Ladebildschirm ein Ladebildschirm angezeigt wird Laden abgeschlossen ist, bevor die Anzeige geschlossen wird, schließen Sie den Ladebildschirm in OnAdDidDismissFullScreenContent-Event-Handler.
  • Auf der iOS-Plattform wird mit AppStateEventNotifier eine Instanz von AppStateEventClient GameObject erstellt. GameObject ist für Veranstaltungen erforderlich also zerstören Sie es nicht. Ereignisse werden nicht mehr ausgelöst, wenn die GameObject zerstört wird.

Zusätzliche Ressourcen