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 und Erstellung eines eigenen Anzeigenblocks IDs zur Verwendung in Ihrer App – konfigurieren Sie Ihr Gerät explizit als Test. Gerät während Entwicklung.

/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

App-Start-Anzeigen werden mit der statischen Load()-Methode auf 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);
          });
  }

Warnung: Es wird versucht, eine neue Anzeige aus dem Block für den Abschluss der Anzeigenanfrage zu laden, wenn eine Anzeige nicht geladen werden kann, wird dringend davon abgeraten. Wenn Sie eine Anzeige aus der Anzeige laden müssen Anforderungsabschlussblock, begrenzen Sie Wiederholungsversuche zum Laden von Anzeigen, um kontinuierliche fehlgeschlagene Anzeigenanfragen, beispielsweise bei eingeschränkter Netzwerkverbindung.

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. Warte auf Dazu registrieren Sie einen Bevollmächtigten, 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 :Bei App-Start-Anzeigen tritt nach vier Stunden eine Zeitüberschreitung auf. Anzeigen gerendert mehr als sind dann nicht mehr gültig und erzielen möglicherweise keinen Umsatz.

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. Ladezeit in _expireTime zwischenspeichern .

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

AppStateEventNotifier verwenden, um den Vordergrund der Anwendung und Hintergrundereignisse. Diese Klasse löst das AppStateChanged-Ereignis immer dann aus, wenn App-Vorder- oder -Hintergründe.

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.

Hinweis :App-Start-Anzeigen sollten während natürlicher Pausen eingeblendet werden. eine App. Ein gutes Beispiel zwischen den Levels eines Spiels oder nach Abschluss des eine Aufgabe.

/// <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 ausgeliefert wird, 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 für 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 der Anzeigenanfrage und dem Erhalt der Anzeige kann dazu führen, dass Nutzende Ihre App kurz verwenden können, wenn sie von einer Anzeige überrascht werden, die außerhalb des Kontexts liegt. Dies sollte vermieden werden, schlechte User Experience ausmacht.

App-Start-Anzeigen werden bei Kaltstarts vorzugsweise über einen 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.

Wichtig :Damit App-Assets weiterhin geladen werden, während die App-Start-Anzeige sollten Assets immer in einem Hintergrundthread geladen werden.

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. Auf Folgendes solltet ihr jedoch am besten achten, damit die Nutzer deine App gern verwenden.

• Präsentieren Sie Ihre erste App-Start-Anzeige, nachdem 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 instanziiert AppStateEventNotifier eine AppStateEventClient GameObject. GameObject ist für Veranstaltungen erforderlich also zerstören Sie es nicht. Ereignisse werden nicht mehr ausgelöst, wenn GameObject: zerstört haben.

Zusätzliche Ressourcen

• HelloWorld-Beispiel: Eine minimale Implementierung aller Anzeigenformate.