Banery reklamowe

Banery reklamowe to prostokątne reklamy, które zajmują część układu aplikacji. Pozostają na ekranie, gdy użytkownicy wchodzą w interakcję z aplikacją – są zakotwiczone u góry lub u dołu ekranu albo w tekście podczas przewijania. Banery reklamowe mogą być automatycznie odświeżane po upływie określonego czasu. Aby dowiedzieć się więcej, zapoznaj się z artykułem Omówienie banerów reklamowych.

Z tego przewodnika dowiesz się, jak zacząć korzystać z zakotwiczonych adaptacyjnych banerów reklamowych, które pozwolą Ci zmaksymalizować skuteczność dzięki optymalizacji rozmiaru reklamy dla każdego urządzenia z wykorzystaniem określonej szerokości reklamy.

Zakotwiczone banery adaptacyjne to reklamy o stałym współczynniku proporcji, a nie reklamy o stałym rozmiarze. Jest on podobny do standardowego standardu 320 x 50. Gdy podasz pełną dostępną szerokość, wyświetli Ci się reklama o optymalnej wysokości dla tej szerokości. Optymalna wysokość nie zmienia się w zależności od żądania wysyłanego z tego samego urządzenia, a okoliczne widoki nie muszą się zmieniać przy odświeżaniu reklamy.

Wymagania wstępne

• Wykonaj czynności opisane w przewodniku dla początkujących.

Zawsze korzystaj z reklam testowych

Podczas tworzenia i testowania aplikacji używaj reklam testowych, a nie aktywnych reklam produkcyjnych. Jeśli tego nie zrobisz, Twoje konto może zostać zawieszone.

Najprostszym sposobem na wczytanie reklam testowych jest użycie naszego dedykowanego identyfikatora testowej jednostki reklamowej dla banerów na Androida:

/6499/example/adaptive-banner

Został on specjalnie skonfigurowany tak, aby zwracał reklamy testowe w odpowiedzi na każde żądanie i możesz go używać we własnych aplikacjach podczas kodowania, testowania i debugowania. Pamiętaj, by przed opublikowaniem aplikacji zastąpić go własnym identyfikatorem jednostki reklamowej.

Więcej informacji o działaniu reklam testowych z pakietu SDK do reklam mobilnych znajdziesz w artykule Reklamy testowe.

Dodaj AdManagerAdView do układu

Pierwszym krokiem do wyświetlenia banera jest umieszczenie elementu AdManagerAdView w układzie elementu Activity lub Fragment, w którym chcesz go wyświetlać.

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)
}

Wczytaj reklamę

Następnym krokiem po utworzeniu AdManagerAdView jest wczytanie reklamy. Służy do tego metoda loadAd() w klasie AdManagerAdView. Wykorzystuje parametr AdManagerAdRequest, który przechowuje w przypadku pojedynczego żądania reklamy informacje o czasie działania, np. o kierowaniu.

Ten przykład pokazuje, jak wczytać reklamę za pomocą metody onCreate() elementu Activity:

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)
}

Jeśli reklama się nie wczytuje, nie musisz wysyłać wyraźnie prośby o kolejną, o ile jednostka reklamowa jest skonfigurowana tak, aby się odświeżała. Pakiet SDK do reklam mobilnych Google respektuje częstotliwość odświeżania określoną Ad Manager w interfejsie internetowym. Jeśli nie masz włączonego odświeżania, musisz wysłać nowe żądanie.

Znakomicie. W Twojej aplikacji są już gotowe do wyświetlania banerów reklamowych.

Zdarzenia reklamowe

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.
    }
}

Każda z metod zastępujących w metodzie AdListener odpowiada zdarzeniu w cyklu życia reklamy.

Akceleracja sprzętowa na potrzeby reklam wideo

Aby reklamy wideo mogły się wyświetlać w ramach wyświetleń banera reklamowego, musisz włączyć akcelerację sprzętową.

Jest ona domyślnie włączona, ale niektóre aplikacje mogą ją wyłączyć. Jeśli dotyczy to Twojej aplikacji, zalecamy włączenie akceleracji sprzętowej dla klas Activity, które używają reklam.

Włączanie akceleracji sprzętowej

Jeśli aplikacja nie działa prawidłowo, gdy akceleracja sprzętowa jest włączona globalnie, możesz ją kontrolować również w przypadku poszczególnych aktywności. Aby włączyć lub wyłączyć akcelerację sprzętową, możesz użyć atrybutu android:hardwareAccelerated dla elementów <application> i <activity> w elemencie AndroidManifest.xml. Poniższy przykład włącza akcelerację sprzętową w całej aplikacji, ale wyłącza ją w przypadku jednego działania:

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

Więcej informacji o opcjach sterowania akceleracją sprzętową znajdziesz w przewodniku po akceleracji sprzętowej. Pamiętaj, że akceleracji sprzętowej nie można włączyć akceleracji sprzętowej w poszczególnych wyświetleniach reklam, jeśli dana aktywność jest wyłączona. W tym przypadku działanie akceleracji sprzętowej musi być włączone.

Ręczne liczenie wyświetleń

Ręczne liczenie wyświetleń jest zgodne tylko z kampaniami sprzedawanymi bezpośrednio i autoreklamami zawierającymi kreacje trafikowane bezpośrednio w usłudze Ad Manager. Nie należy go używać w przypadku reklam zapasowych ani reklam z sieci zewnętrznych. Więcej informacji znajdziesz w artykule Zliczanie wyświetleń i kliknięć.

Możesz ręcznie wysyłać pingi wyświetleń do Ad Managera, jeśli masz specjalne warunki określające, kiedy należy rejestrować wyświetlenia. Aby to zrobić, przed wczytaniem reklamy włącz obsługę wyświetleń ręcznych przez AdManagerAdRequest:

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

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

Gdy stwierdzisz, że reklama została zwrócona i jest widoczna na ekranie, możesz zarejestrować wyświetlenie ręcznie:

AdManagerAdView.recordManualImpression();

AdManagerAdView.recordManualImpression()

Zdarzenia w aplikacjach

Zdarzenia w aplikacji umożliwiają tworzenie reklam, które mogą wysyłać wiadomości do kodu swojej aplikacji. Na podstawie tych komunikatów aplikacja może podejmować działania.

Możesz nasłuchiwać zdarzeń z aplikacji Ad Managera za pomocą funkcji AppEventListener. Te zdarzenia mogą wystąpić w dowolnym momencie cyklu życia reklamy, nawet przed wywołaniem funkcji onAdLoaded().

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

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

void onAppEvent(String name, String info) jest wywoływany, gdy w reklamie wystąpi zdarzenie w aplikacji. Ten interfejs można zaimplementować za pomocą działania lub dowolnego innego obiektu:

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 {
}

a następnie przekazano do interfejsu AdManagerAdView:

AdManagerAdView.setAppEventListener(this);

AdManagerAdView.appEventListener = this

Ten przykład pokazuje, jak zmienić kolor tła aplikacji w zależności od zdarzenia w aplikacji o nazwie koloru:

@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.
            }
        }
    }
}

A oto kreacja, która wysyła do detektora wiadomości o zdarzeniach w aplikacji Kolor:

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

Przykład implementacji zdarzeń w aplikacji w aplikacji demonstracyjnej interfejsu API znajdziesz w tym przykładzie.

Java Kotlin

Dodatkowe materiały

Przykłady w GitHubie

• Przykład zakotwiczonych banerów adaptacyjnych: Java | Kotlin

• Prezentacja funkcji zaawansowanych: Java | Kotlin

Dalsze kroki

Banery zwijane

Zwijane banery reklamowe to banery reklamowe, które są początkowo wyświetlane jako większa nakładka z przyciskiem umożliwiającym zwijanie reklamy do mniejszego rozmiaru. Możesz użyć ich do dalszej optymalizacji skuteczności. Więcej informacji znajdziesz w artykule o zwijanych banerach reklamowych.

Wbudowane banery adaptacyjne

Wbudowane banery adaptacyjne są większe i wyższe w porównaniu do zakotwiczonych banerów adaptacyjnych. Mają zmienną wysokość, a ich wysokość może sięgać ekranu urządzenia. W przypadku aplikacji, które umieszczają banery reklamowe w przewijanych treściach, zalecamy stosowanie wbudowanych banerów adaptacyjnych zamiast zakotwiczonych banerów adaptacyjnych. Więcej informacji znajdziesz w sekcji Wbudowane banery adaptacyjne.

Przeglądaj inne tematy

• Prywatność użytkowników
• Optymalizowanie inicjowania i wczytywania reklam przez pakiet SDK (beta)