App-Start-Anzeigen einrichten

SDK.

Plattform auswählen: Android iOS Unity Flutter Android (Legacy)

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

Weitere Informationen finden Sie in den Richtlinien für App-Start-Anzeigen.

In dieser Anleitung wird erläutert, wie Sie App-Start-Anzeigen in eine Android-App einbinden.

Hinweis

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

  • Richten Sie GMA Next-Gen SDK ein.
  • Verwenden Sie die Test-Anzeigenblock-ID für App-Start-Anzeigen /6499/example/app-open.
    • Achten Sie beim Erstellen und Testen Ihrer App darauf, dass Sie Testanzeigen und keine Live-Anzeigen verwenden. Wenn Sie die Test-Anzeigenblock-ID nicht verwenden, kann Google Ihr Konto sperren.
    • Ersetzen Sie diese ID vor der Veröffentlichung Ihrer App durch Ihre Anzeigenblock-ID.
    • Weitere Informationen zu GMA Next-Gen SDK Testanzeigen finden Sie unter Testanzeigen aktivieren.

Grundlegendes zum Vorabladen von Anzeigen

Beim Vorabladen von Anzeigen in GMA Next-Gen SDK werden Anzeigen automatisch geladen und im Cache gespeichert.

Das Vorabladen von Anzeigen bietet folgende Vorteile:

  • Referenzverwaltung: Referenzen werden beibehalten, bis Anzeigen eingeblendet werden.
  • Automatisches Neuladen: Eine neue Anzeige wird geladen, wenn eine aus dem Cache abgerufen wird.
  • Verwaltete Wiederholungen: Eine neue Anzeige wird geladen, wenn das Laden einer Anzeige fehlschlägt.
  • Ablaufbehandlung: Anzeigen werden aktualisiert, bevor sie ablaufen.
  • Cache-Optimierung: Die Cache-Reihenfolge wird optimiert, um die Anzeige mit der höchsten Priorität auszuliefern.

Vorabladen von Anzeigen starten

Rufen Sie die Methode start einmal beim Start der App auf, um mit dem Vorabladen von Anzeigen zu beginnen. Nachdem Sie die Methode start aufgerufen haben, GMA Next-Gen SDK lädt automatisch Anzeigen vorab und wiederholt fehlgeschlagene Anfragen für vorab geladene Konfigurationen.

Im folgenden Beispiel wird gezeigt, wie Sie das Vorabladen von Anzeigen starten:

Kotlin

private fun startPreloading(adUnitId: String) {
  val adRequest = AdRequest.Builder(adUnitId).build()
  val preloadConfig = PreloadConfiguration(adRequest)
  AppOpenAdPreloader.start(adUnitId, preloadConfig)
}

Java

private void startPreloading(String adUnitId) {
  AdRequest adRequest = new AdRequest.Builder(adUnitId).build();
  PreloadConfiguration preloadConfig = new PreloadConfiguration(adRequest);
  AppOpenAdPreloader.start(adUnitId, preloadConfig);
}

Ersetzen Sie AD_UNIT_ID durch Ihre Anzeigenblock-ID.

Im vorherigen Beispiel wird gezeigt, wie Sie die Anzeigenblock-ID als Vorabladungs-ID verwenden. Eine Vorabladungs-ID ist ein String-Identifier, den Sie erstellen, um eine Konfiguration für das Vorabladen von Anzeigen zu identifizieren. Wenn Ihre App mehrere Targeting-Konfigurationen für dieselbe Anzeigenblock-ID erfordert, übergeben Sie einen benutzerdefinierten String-Identifier.

Vorab geladene Anzeigen abrufen und einblenden

Wenn Sie eine Anzeige einblenden möchten, rufen Sie die Methode pollAd auf. GMA Next-Gen SDK ruft eine verfügbare Anzeige ab und lädt automatisch die nächste Anzeige im Hintergrund vorab. Wenn keine Anzeige verfügbar ist, gibt GMA Next-Gen SDK keine Anzeigen zurück.

Wenn Sie ein verfügbares Anzeigenobjekt haben, rufen Sie die Methode show auf, um die Anzeige einzublenden. Im folgenden Beispiel wird gezeigt, wie Sie eine vorab geladene Anzeige abrufen und einblenden:

Kotlin

private fun pollAndShowAd(activity: Activity, adUnitId: String) {
  // Polling returns the next available ad and loads another ad in the background.
  val ad = AppOpenAdPreloader.pollAd(adUnitId)
  if (ad == null) {
    Log.e(TAG, "App open ad is not available.")
    return
  }

  // Interact with the ad object as needed.
  Log.d(TAG, "App open ad response info: ${ad.getResponseInfo()}")
  ad.adEventCallback =
    object : AppOpenAdEventCallback {
      override fun onAdImpression() {
        Log.d(TAG, "App open ad recorded an impression.")
      }
    }
  ad.show(activity)
}

Java

private void pollAndShowAd(Activity activity, String adUnitId) {
  // Polling returns the next available ad and loads another ad in the background.
  AppOpenAd ad = AppOpenAdPreloader.pollAd(adUnitId);

  // Interact with the ad object as needed.
  if (ad == null) {
    Log.e(TAG, "App open ad is not available.");
    return;
  }

  Log.d(TAG, "App open ad response info: " + ad.getResponseInfo());
  ad.setAdEventCallback(
      new AppOpenAdEventCallback() {
        @Override
        public void onAdImpression() {
          Log.d(TAG, "App open ad recorded an impression.");
        }
      });

  // Show the ad.
  ad.show(activity);
}

Rufen Sie die Methode pollAd erst auf, wenn Sie bereit sind, eine Anzeige einzublenden. Informationen zum Lesen der Anzeigenantwort, ohne die Anzeige einzublenden, finden Sie unter Antwortinformationen lesen.

Auf Anzeigenereignisse warten

Warten Sie vor dem Einblenden der Anzeige auf Anzeigenereignisse. Im folgenden Beispiel wird gezeigt, wie Sie Callbacks für Anzeigenereignisse registrieren:

Kotlin

private fun listenToAdEvents() {
  // Listen for ad events.
  val ad = appOpenAd
  if (ad == null) {
    Log.e(TAG, "App open ad is not ready yet.")
    return
  }

  ad.adEventCallback =
    object : AppOpenAdEventCallback {
      override fun onAdShowedFullScreenContent() {
        // App open ad did show.
      }

      override fun onAdDismissedFullScreenContent() {
        // App open ad did dismiss.
        appOpenAd = null
      }

      override fun onAdFailedToShowFullScreenContent(
        fullScreenContentError: FullScreenContentError
      ) {
        // App open ad failed to show.
        Log.e(TAG, "App open ad failed to show: ${fullScreenContentError.message}")
      }

      override fun onAdImpression() {
        // App open ad did record an impression.
      }

      override fun onAdClicked() {
        // App open ad did record a click.
      }
    }
}

Java

private void listenToAdEvents() {
  // Listen for ad events.
  if (appOpenAd == null) {
    Log.e(TAG, "App open ad is not ready yet.");
    return;
  }

  appOpenAd.setAdEventCallback(
      new AppOpenAdEventCallback() {
        @Override
        public void onAdShowedFullScreenContent() {
          // App open ad did show.
        }

        @Override
        public void onAdDismissedFullScreenContent() {
          // App open ad did dismiss.
          appOpenAd = null;
        }

        @Override
        public void onAdFailedToShowFullScreenContent(
            @NonNull FullScreenContentError fullScreenContentError) {
          // App open ad failed to show.
          Log.e(TAG, "App open ad failed to show: " + fullScreenContentError.getMessage());
        }

        @Override
        public void onAdImpression() {
          // App open ad did record an impression.
        }

        @Override
        public void onAdClicked() {
          // App open ad did record a click.
        }
      });
}

Optional: Auf Ereignisse zum Vorabladen warten

Wenn Sie mit dem Vorabladen von Anzeigen beginnen, registrieren Sie sich für Ereignisse zum Vorabladen, um benachrichtigt zu werden, wenn Anzeigen erfolgreich vorab geladen wurden, das Vorabladen fehlschlägt oder der Anzeigen-Cache erschöpft ist.

Im folgenden Beispiel wird gezeigt, wie Sie sich für Ereignisse zum Vorabladen von Anzeigen registrieren:

Kotlin

private fun startPreloadingWithCallback(adUnitId: String) {
  val preloadCallback =
    object : PreloadCallback {
      override fun onAdFailedToPreload(preloadId: String, adError: LoadAdError) {
        Log.d(TAG, "App open preload ad $preloadId failed to load with error: ${adError.message}")
      }

      override fun onAdsExhausted(preloadId: String) {
        Log.i(TAG, "App open preload ad $preloadId is not available")
      }

      override fun onAdPreloaded(preloadId: String, responseInfo: ResponseInfo) {
        Log.i(TAG, "App open preload ad $preloadId is available")
      }
    }
  val adRequest = AdRequest.Builder(adUnitId).build()
  val preloadConfig = PreloadConfiguration(adRequest)
  AppOpenAdPreloader.start(adUnitId, preloadConfig, preloadCallback)
}

Java

private void startPreloadingWithCallback(String adUnitId) {
  PreloadCallback preloadCallback =
      new PreloadCallback() {
        @Override
        public void onAdFailedToPreload(@NonNull String preloadId, @NonNull LoadAdError adError) {
          Log.d(
              TAG,
              String.format(
                  "App open preload ad %s failed to load with error: %s",
                  preloadId, adError.getMessage()));
        }

        @Override
        public void onAdsExhausted(@NonNull String preloadId) {
          Log.i(TAG, String.format("App open preload ad %s is not available", preloadId));
        }

        @Override
        public void onAdPreloaded(@NonNull String preloadId, @NonNull ResponseInfo responseInfo) {
          Log.i(TAG, String.format("App open preload ad %s is available", preloadId));
        }
      };
  AdRequest adRequest = new AdRequest.Builder(adUnitId).build();
  PreloadConfiguration preloadConfig = new PreloadConfiguration(adRequest);
  AppOpenAdPreloader.start(adUnitId, preloadConfig, preloadCallback);
}

Wenn das Laden einer Anzeige fehlschlägt, lädt GMA Next-Gen SDK automatisch Anzeigen vorab und wiederholt fehlgeschlagene Anfragen für vorab geladene Konfigurationen.

Optional: Verfügbarkeit von Anzeigen prüfen

Wenn Sie wissen müssen, ob eine Anzeige verfügbar ist, prüfen Sie die Verfügbarkeit von Anzeigen. Im folgenden Beispiel wird gezeigt, wie Sie prüfen, ob eine vorab geladene Anzeige verfügbar ist:

Kotlin

private fun isAdAvailable(adUnitId: String): Boolean {
  return AppOpenAdPreloader.isAdAvailable(adUnitId)
}

Java

private boolean isAdAvailable(String adUnitId) {
  return AppOpenAdPreloader.isAdAvailable(adUnitId);
}

Optional: Puffergröße festlegen

Die Puffergröße steuert die Anzahl der vorab geladenen Anzeigen, die im Arbeitsspeicher gespeichert werden. Standardmäßig optimiert Google die Puffergröße, um ein Gleichgewicht zwischen Arbeitsspeicherverbrauch und Latenz bei der Anzeigenauslieferung zu schaffen. Sie können eine benutzerdefinierte Puffergröße festlegen, um die Anzahl der im Arbeitsspeicher gespeicherten Anzeigen zu erhöhen. Wir empfehlen eine maximale Puffergröße von vier.

Im folgenden Beispiel wird gezeigt, wie Sie eine Puffergröße von vier vorab geladenen Anzeigen festlegen:

Kotlin

private fun setBufferSize(adUnitId: String) {
  val adRequest = AdRequest.Builder(adUnitId).build()
  // Four is the recommended maximum buffer size.
  val preloadConfig = PreloadConfiguration(adRequest, bufferSize = 4)
  AppOpenAdPreloader.start(adUnitId, preloadConfig)
}

Java

private void setBufferSize(String adUnitId) {
  AdRequest adRequest = new AdRequest.Builder(adUnitId).build();
  // Four is the recommended maximum buffer size.
  PreloadConfiguration preloadConfig = new PreloadConfiguration(adRequest, 4);
  AppOpenAdPreloader.start(adUnitId, preloadConfig);
}

Limits für den Vorabladungs-Cache

GMA Next-Gen SDK erzwingt ein app-weites Limit für die Gesamtzahl der vorab geladenen Anzeigen für alle Anzeigenblöcke und Vorabladungs-IDs:

  • Standardlimit: Google speichert maximal sechs vorab geladene Anzeigen im Arbeitsspeicher. Dieses Limit gilt für alle Formate und Vorabladungs-IDs.
  • Wir empfehlen eine Puffergröße von zwei oder drei pro Vorabladungs-ID.

Optional: Vorabladen von Anzeigen beenden

Wenn Sie in der Sitzung keine Anzeigen für eine bestimmte Vorabladungs-ID mehr einblenden müssen, können Sie das Vorabladen von Anzeigen beenden. Rufen Sie die Methode destroy mit einer Vorabladungs-ID auf, um das Laden von Anzeigen für eine bestimmte Vorabladungs-ID zu beenden. Wenn Sie die Methode destroy aufrufen, werden alle vorab geladenen Anzeigen, die mit der Vorabladungs-ID verknüpft sind, aus dem Cache entfernt.

Im folgenden Beispiel wird gezeigt, wie Sie das Vorabladen von Anzeigen beenden:

Kotlin

private fun stopPreloading(adUnitId: String) {
  // Stops the preloading and destroy preloaded ads.
  AppOpenAdPreloader.destroy(adUnitId)
}

Java

private void stopPreloading(String adUnitId) {
  // Stops the preloading and destroy preloaded ads.
  AppOpenAdPreloader.destroy(adUnitId);
}

Optional: Antwortinformationen lesen

Lesen Sie die Antwortinformationen der nächsten vorab geladenen Anzeige, ohne die Anzeige aus dem Cache zu entfernen.

Im folgenden Beispiel wird gezeigt, wie Sie die Informationen der nächsten vorab geladenen Anzeigenantwort lesen:

Kotlin

val responseInfo = AppOpenAdPreloader.peekAdResponseInfo(preloadId)
if (responseInfo == null) {
  Log.e(TAG, "Failed to peek ad response info.")
  return
}

Log.d(TAG, "Peeked ad response ID: ${responseInfo.responseId}")

Java

ResponseInfo responseInfo = AppOpenAdPreloader.peekAdResponseInfo(preloadId);
if (responseInfo == null) {
  Log.e(TAG, "Failed to peek ad response info.");
  return;
}

Log.d(TAG, "Peeked ad response ID: " + responseInfo.getResponseId());

Kaltstarts und Ladebildschirme

Ein Kaltstart tritt auf, wenn Ihre App von Grund auf neu gestartet wird, z. B. wenn ein Nutzer Ihre App zum ersten Mal öffnet oder nach einer Speicherbeendigung. Bei einem Kaltstart haben Sie keine zuvor geladene App-Start-Anzeige, die sofort eingeblendet werden kann.

Aufgrund von Verzögerungen bei der Anzeigenanfrage interagieren Nutzer möglicherweise mit Ihrer App, bevor eine App-Start-Anzeige eingeblendet wird. Um eine schlechte Nutzererfahrung zu vermeiden, blenden Sie App-Start-Anzeigen bei Kaltstarts nur auf einem Ladebildschirm ein, während die App-Assets geladen werden. Wenn das Laden der Assets abgeschlossen ist und der Nutzer den Hauptinhalt erreicht, bevor die Anzeige geladen wird, blenden Sie die Anzeige nicht ein.

Laden Sie App-Assets in einem Hintergrundthread, damit das Laden fortgesetzt wird, während die Anzeige eingeblendet wird.

Best Practices

Wir empfehlen folgende Best Practices für App-Start-Anzeigen:

  • Blenden Sie die erste App-Start-Anzeige erst ein, nachdem ein Nutzer Ihre App mehrmals geöffnet hat.
  • Blenden Sie App-Start-Anzeigen nur ein, während Nutzer darauf warten, dass Ihre App geladen wird.
  • Wenn der Ladebildschirm geladen ist, während die Anzeige eingeblendet wird, schließen Sie den Ladebildschirm in der Callback-Methode für das Schließen der Anzeige.