Banneranzeigen

Banneranzeigen sind rechteckige Anzeigen, die einen Teil der App-Oberfläche einnehmen. Sie bleiben auf dem Bildschirm, während Nutzer mit der App interagieren. Sie sind entweder oben oder unten auf dem Bildschirm verankert oder inline mit dem Inhalt, wenn der Nutzer scrollt. Banneranzeigen können nach einer bestimmten Zeit automatisch aktualisiert werden. Weitere Informationen finden Sie unter Übersicht über Banneranzeigen.

In diesem Leitfaden werden die ersten Schritte mit verankerten adaptiven Banneranzeigenbeschrieben. Damit lässt sich die Leistung maximieren, da die Anzeigengröße für jedes Gerät mit einer von Ihnen angegebenen Anzeigenbreite optimiert wird.

Als verankerte adaptive Banneranzeigen werden anstelle von herkömmlichen Anzeigen mit fester Größe Anzeigen mit einem festen Seitenverhältnis verwendet. Das Seitenverhältnis entspricht dem Branchenstandard 320 x 50. Wenn Sie die volle Breite angeben, wird eine Anzeige mit der optimalen Höhe für diese Breite zurückgegeben. Die optimale Höhe ändert sich nicht bei Anfragen von demselben Gerät. Auch die umgebenden Ansichten müssen sich beim Aktualisieren der Anzeige nicht verschieben.

Voraussetzungen

• Arbeiten Sie den Startleitfaden durch.

Immer mit Testanzeigen testen

Verwenden Sie beim Erstellen und Testen Ihrer Apps Testanzeigen und keine Liveanzeigen. Andernfalls kann Ihr Konto gesperrt werden.

Testanzeigen lassen sich am einfachsten mit unserer speziellen Test-ID für Anzeigenblöcke für Android-Banner laden:

/6499/example/adaptive-banner

Sie wurde speziell so konfiguriert, dass bei jeder Anfrage Testanzeigen zurückgegeben werden. Sie können sie beim Programmieren, Testen und Debuggen in Ihren eigenen Apps verwenden. Ersetzen Sie sie einfach durch Ihre eigene Anzeigenblock-ID, bevor Sie Ihre App veröffentlichen.

Weitere Informationen zur Funktionsweise der Testanzeigen des Mobile Ads SDK finden Sie unter Testanzeigen.

AdManagerAdView zum Layout hinzufügen

Damit ein Banner angezeigt werden kann, musst du zuerst AdManagerAdView im Layout für das Activity oder Fragment platzieren, in dem das Banner angezeigt werden soll:

private AdSize getAdSize() {
  // Determine the screen width (less decorations) to use for the ad width.
  Display display = getWindowManager().getDefaultDisplay();
  DisplayMetrics outMetrics = new DisplayMetrics();
  display.getMetrics(outMetrics);

  float density = outMetrics.density;

  float adWidthPixels = adContainerView.getWidth();

  // If the ad hasn't been laid out, default to the full screen width.
  if (adWidthPixels == 0) {
    adWidthPixels = outMetrics.widthPixels;
  }

  int adWidth = (int) (adWidthPixels / density);
  return AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize(this, adWidth);
}

private void loadBanner() {
  
  // Create a new ad view.
  AdManagerAdView adView = new AdManagerAdView(this);
  adView.setAdSizes(getAdSize());
  adView.setAdUnitId("/6499/example/adaptive-banner");

  // Replace ad container with new ad view.
  adContainerView.removeAllViews();
  adContainerView.addView(adView);

  // Start loading the ad in the background.
  AdManagerAdRequest adRequest = new AdManagerAdRequest.Builder().build();
  adView.loadAd(adRequest);
}

// Determine the screen width (less decorations) to use for the ad width.
// If the ad hasn't been laid out, default to the full screen width.
private val adSize: AdSize
  get() {
    val display = windowManager.defaultDisplay
    val outMetrics = DisplayMetrics()
    display.getMetrics(outMetrics)

    val density = outMetrics.density

    var adWidthPixels = binding.adViewContainer.width.toFloat()
    if (adWidthPixels == 0f) {
      adWidthPixels = outMetrics.widthPixels.toFloat()
    }

    val adWidth = (adWidthPixels / density).toInt()
    return AdSize.getCurrentOrientationAnchoredAdaptiveBannerAdSize(this, adWidth)
  }

private fun loadBanner() {
  
  // Create a new ad view.
  val adView = AdManagerAdView(this)
  adView.adSizes = adSize
  adView.adUnitId = "/6499/example/adaptive-banner"

  // Create an ad request.
  val adRequest = AdManagerAdRequest.Builder().build()

  // Start loading the ad in the background.
  adView.loadAd(adRequest)
}

Anzeige laden

Sobald AdManagerAdView vorhanden ist, wird im nächsten Schritt eine Anzeige geladen. Dazu verwenden Sie die Methode loadAd() in der Klasse AdManagerAdView. Es wird ein AdManagerAdRequest-Parameter verwendet, der Laufzeitinformationen zu einer einzelnen Anzeigenanfrage enthält, z. B. Targeting-Informationen.

Das folgende Beispiel zeigt, wie eine Anzeige in der onCreate()-Methode eines Activity geladen wird:

private void loadBanner() {
  // Create a new ad view.
  adView = new AdManagerAdView(this);
  adView.setAdUnitId(AD_UNIT);
  adView.setAdSize(getAdSize());
  
  // Replace ad container with new ad view.
  adContainerView.removeAllViews();
  adContainerView.addView(adView);

  // Start loading the ad in the background.
  AdManagerAdRequest adRequest = new AdManagerAdRequest.Builder().build();
  adView.loadAd(adRequest);
}

private fun loadBanner() {
  // This is an ad unit ID for a test ad. Replace with your own banner ad unit ID.
  adView.adUnitId = "/6499/example/banner"
  adView.setAdSize(adSize)
  
  // Create an ad request.
  val adRequest = AdManagerAdRequest.Builder().build()

  // Start loading the ad in the background.
  adView.loadAd(adRequest)
}

Wenn Ihre Anzeige nicht geladen werden kann, müssen Sie nicht explizit eine weitere anfordern, solange Sie Ihren Anzeigenblock für die Aktualisierung konfiguriert haben. Das Google Mobile Ads SDK berücksichtigt jede Aktualisierungsrate, die Sie in der Weboberfläche Ad Managerangegeben haben. Wenn Sie die Aktualisierung nicht aktiviert haben, müssen Sie eine neue Anfrage senden.

Fertig! In Ihrer App können jetzt Banneranzeigen ausgeliefert werden.

Anzeigenereignisse

AdManagerAdView.setAdListener(new AdListener() {
    @Override
    public void onAdClicked() {
      // Code to be executed when the user clicks on an ad.
    }

    @Override
    public void onAdClosed() {
      // Code to be executed when the user is about to return
      // to the app after tapping on an ad.
    }

    @Override
    public void onAdFailedToLoad(LoadAdError adError) {
      // Code to be executed when an ad request fails.
    }

    @Override
    public void onAdImpression() {
      // Code to be executed when an impression is recorded
      // for an ad.
    }

    @Override
    public void onAdLoaded() {
      // Code to be executed when an ad finishes loading.
    }

    @Override
    public void onAdOpened() {
      // Code to be executed when an ad opens an overlay that
      // covers the screen.
    }
});

AdManagerAdView.adListener = object: AdListener() {
    override fun onAdClicked() {
      // Code to be executed when the user clicks on an ad.
    }

    override fun onAdClosed() {
      // Code to be executed when the user is about to return
      // to the app after tapping on an ad.
    }

    override fun onAdFailedToLoad(adError : LoadAdError) {
      // Code to be executed when an ad request fails.
    }

    override fun onAdImpression() {
      // Code to be executed when an impression is recorded
      // for an ad.
    }

    override fun onAdLoaded() {
      // Code to be executed when an ad finishes loading.
    }

    override fun onAdOpened() {
      // Code to be executed when an ad opens an overlay that
      // covers the screen.
    }
}

Jede der überschreibbaren Methoden in AdListener entspricht einem Ereignis im Lebenszyklus einer Anzeige.

Hardwarebeschleunigung für Videoanzeigen

Damit Videoanzeigen in den Aufrufen Ihrer Banneranzeigen ausgeliefert werden, muss die Hardwarebeschleunigung aktiviert sein.

Die Hardwarebeschleunigung ist standardmäßig aktiviert, kann jedoch von einigen Apps deaktiviert werden. Wenn dies auf Ihre App zutrifft, empfehlen wir, die Hardwarebeschleunigung für Activity-Klassen zu aktivieren, die Anzeigen verwenden.

Hardwarebeschleunigung aktivieren

Wenn Ihre Anwendung bei aktivierter Hardwarebeschleunigung nicht ordnungsgemäß funktioniert, können Sie sie auch für einzelne Aktivitäten steuern. Zum Aktivieren oder Deaktivieren der Hardwarebeschleunigung können Sie das Attribut android:hardwareAccelerated für die Elemente <application> und <activity> in AndroidManifest.xml verwenden. Im folgenden Beispiel wird die Hardwarebeschleunigung für die gesamte App aktiviert, aber für eine Aktivität deaktiviert:

<application android:hardwareAccelerated="true">
    <!-- For activities that use ads, hardwareAcceleration should be true. -->
    <activity android:hardwareAccelerated="true" />
    <!-- For activities that don't use ads, hardwareAcceleration can be false. -->
    <activity android:hardwareAccelerated="false" />
</application>

Weitere Informationen zu Optionen zur Steuerung der Hardwarebeschleunigung findest du im Leitfaden zur Hardwarebeschleunigung. Für einzelne Anzeigenaufrufe kann die Hardwarebeschleunigung nicht aktiviert werden, wenn die Aktivität deaktiviert ist. Für die Aktivität selbst muss also die Hardwarebeschleunigung aktiviert sein.

Manuelle Impressionen zählen

Die manuelle Zählung von Impressionen ist nur mit direkt verkauften und hausinternen Kampagnen mit Creatives kompatibel, die direkt in Ad Manager getraffickt werden. Er sollte nicht für Backfill-Anzeigen oder Anzeigen in Drittanbieter-Werbenetzwerken verwendet werden. Weitere Informationen finden Sie unter Impressionen und Klicks zählen.

Sie können Impressions-Pings manuell an Ad Manager senden, wenn eine Impression unter besonderen Bedingungen erfasst werden soll. Aktivieren Sie dazu einen AdManagerAdRequest für manuelle Impressionen, bevor eine Anzeige geladen wird:

AdManagerAdRequest adRequest = new AdManagerAdRequest.Builder()
    .setManualImpressionsEnabled(true)
    .build();

val adRequest = AdManagerAdRequest.Builder()
    .setManualImpressionsEnabled(true)
    .build()

Wenn Sie feststellen, dass eine Anzeige zurückgegeben wurde und auf dem Bildschirm zu sehen ist, können Sie manuell eine Impression erfassen:

AdManagerAdView.recordManualImpression();

AdManagerAdView.recordManualImpression()

App-Ereignisse

Mit App-Ereignissen können Sie Anzeigen erstellen, über die Nachrichten an den App-Code gesendet werden. Anhand dieser Meldungen kann die App dann Aktionen ausführen.

Mit AppEventListener lassen sich Ad Manager-spezifische App-Ereignisse erfassen. Diese Ereignisse können im Lebenszyklus der Anzeige jederzeit auftreten, sogar bevor onAdLoaded() aufgerufen wird.

public interface AppEventListener {
  void onAppEvent(String name, String info);
}

interface AppEventListener {
    fun onAppEvent(name: String, info: String)
}

void onAppEvent(String name, String info) wird aufgerufen, wenn ein App-Ereignis in einer Anzeige auftritt. Diese Schnittstelle kann durch Ihre Aktivität oder ein beliebiges anderes Objekt implementiert werden:

import com.google.android.gms.ads.admanager.*;

public class BannerExample extends Activity implements AppEventListener {
}

import com.google.android.gms.ads.admanager.*

class BannerExample : Activity(), AppEventListener {
}

und dann an AdManagerAdView übergeben:

AdManagerAdView.setAppEventListener(this);

AdManagerAdView.appEventListener = this

Das folgende Beispiel zeigt, wie Sie die Hintergrundfarbe Ihrer App in Abhängigkeit von einem App-Ereignis mit einem Farbnamen ändern:

@Override
public void onAppEvent(String name, String info) {
  if ("color".equals(name)) {
    if ("green".equals(info)) {
      // Set background color to green.
    } else if ("blue".equals(info)) {
      // Set background color to blue.
    } else {
      // Set background color to black.
    }
  }
}

override fun onAppEvent(name: String?, info: String?) {
    if (name == "color") {
        when (info) {
            "green" -> {
                // Set background color to green.
            }
            "blue" -> {
                // Set background color to blue.
            }
            else -> {
                // Set background color to black.
            }
        }
    }
}

Und hier sehen Sie das entsprechende Creative, von dem App-Ereignisnachrichten mit der Farbe an den Listener gesendet werden:

<html>
<head>
  <script src="//www.gstatic.com/afma/api/v1/google_mobile_app_ads.js"></script>
  <script>
    document.addEventListener("DOMContentLoaded", function() {
      // Send a color=green event when ad loads.
      admob.events.dispatchAppEvent("color", "green");

      document.getElementById("ad").addEventListener("click", function() {
        // Send a color=blue event when ad is clicked.
        admob.events.dispatchAppEvent("color", "blue");
      });
    });
  </script>
  <style>
    #ad {
      width: 320px;
      height: 50px;
      top: 0px;
      left: 0px;
      font-size: 24pt;
      font-weight: bold;
      position: absolute;
      background: black;
      color: white;
      text-align: center;
    }
  </style>
</head>
<body>
  <div id="ad">Carpe diem!</div>
</body>
</html>

Eine Implementierung von App-Ereignissen in der API Demo App finden Sie im Beispiel zu Ad Manager-App-Ereignissen.

Java Kotlin

Zusätzliche Ressourcen

Beispiele auf GitHub

• Beispiel für verankerte adaptive Banneranzeigen: Java | Kotlin

• Demo der erweiterten Features: Java | Kotlin

Nächste Schritte

Minimierbare Banner

Minimierbare Banneranzeigen sind Banneranzeigen, die anfangs als größeres Overlay präsentiert werden, mit einer Schaltfläche zum Minimieren der Anzeige. Erwägen Sie, damit Ihre Leistung weiter zu optimieren. Weitere Informationen finden Sie unter Minimierbare Banneranzeigen.

Adaptive Inline-Banner

Adaptive Inline-Banner sind größere, höhere Banner im Vergleich zu verankerten adaptiven Bannern. Sie haben eine variable Höhe und können so hoch wie der Gerätebildschirm sein. Adaptive Inline-Banner werden bei Apps, in denen Banneranzeigen in scrollbarem Content platziert werden, vor verankerten adaptiven Banneranzeigen empfohlen. Weitere Informationen finden Sie unter Adaptive Inline-Banner.

Weitere Themen entdecken

• Datenschutz für Nutzer
• SDK-Initialisierung und Anzeigenladen optimieren (Beta)