Banery reklamowe

Banery reklamowe to prostokątne reklamy, które zajmują część układu aplikacji. Ta pozostają na ekranie, gdy użytkownicy wchodzą w interakcję z aplikacją – albo są zakotwiczone, w górnej lub dolnej części ekranu albo w tekście podczas przewijania. Baner reklamy mogą odświeżać się automatycznie po upływie określonego czasu. Przeczytaj Omówienie banerów reklamowych. .

Z tego przewodnika dowiesz się, jak zacząć korzystać z reklam zakotwiczonych adaptacyjne banery reklamowe, które pozwalają zmaksymalizować skuteczność reklam dzięki optymalizacji rozmiaru dla każdego urządzenia o określonej szerokości reklamy.

Zakotwiczone banery adaptacyjne to reklamy o stałym współczynniku proporcji reklamy reklam o stałym rozmiarze. Format obrazu jest podobny do standardu branżowego 320 x 50. Jednorazowo Jeśli podasz pełną szerokość, otrzymasz reklamę o optymalnym wysokość dla tej szerokości. Optymalna wysokość nie zmienia się w zależności od żądań z na tym samym urządzeniu, a widoki nie muszą przesuwać się, gdy reklama odświeża się.

Wymagania wstępne

• Zapoznaj się z przewodnikiem dla początkujących.

Zawsze korzystaj z reklam testowych

Podczas tworzenia i testowania aplikacji używaj reklam testowych, a nie reklam, aktywne reklamy. Jeśli tego nie zrobisz, możemy zawiesić Twoje konto.

Najłatwiejszym sposobem wczytania reklam testowych jest użycie specjalnego identyfikatora testowego Banery na Androida:

/6499/example/adaptive-banner

Został on specjalnie skonfigurowany tak, aby wyświetlać reklamy testowe w odpowiedzi na każde żądanie. Możesz używać go we własnych aplikacjach podczas kodowania, testowania i debugowania. Upewnij się tylko, zastąp go identyfikatorem jednostki reklamowej przed opublikowaniem aplikacji.

Więcej informacji o działaniu reklam testowych w pakiecie SDK do reklam mobilnych znajdziesz w artykule Testowanie Reklamy.

Dodawanie do układu elementu AdManagerAdView

Pierwszym krokiem do wyświetlenia banera jest umieszczenie AdManagerAdView w układzie w elemencie Activity lub Fragment, w którym chcesz wyświetlić :

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

Wczytywanie reklamy

Kolejnym krokiem po skonfigurowaniu AdManagerAdView jest wczytanie reklamy. Można to zrobić dzięki loadAd() w klasie AdManagerAdView. Potrzeba AdManagerAdRequest który zawiera informacje o czasie działania, np. informacje o kierowaniu, pojedynczego żądania reklamy.

Oto przykład, który pokazuje, jak wczytać reklamę w metodzie onCreate() funkcji 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 nie zostanie wczytana, nie trzeba wyraźnie żądać nowej, ponieważ jeśli jednostka reklamowa jest skonfigurowana pod kątem odświeżania, pakiet SDK do reklam mobilnych Google uwzględnia częstotliwość odświeżania określoną w usłudze Ad Manager, za pomocą interfejsu internetowego. Jeśli nie masz włączonego odświeżania, musisz wysłać nowe użytkownika.

Znakomicie. Twoja aplikacja jest już gotowa 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 możliwych do zastąpienia metod w argumencie AdListener odpowiada zdarzeniu w cyklu życia reklamy.

Akceleracja sprzętowa reklam wideo

Aby reklamy wideo były skuteczne w wyświetleniach banerów reklamowych, odpowiedni sprzęt acceleration musi włącz.

Akceleracja sprzętowa jest domyślnie włączona, ale niektóre aplikacje mogą ją wyłączyć . Jeśli dotyczy to Twojej aplikacji, zalecamy włączenie akceleracji sprzętowej na Activity zajęcia, które używają reklam.

Włączam akcelerację sprzętową

Jeśli aplikacja nie działa prawidłowo po włączeniu akceleracji sprzętowej na całym świecie, możesz ją kontrolować również w przypadku poszczególnych działań. Aby włączyć lub wyłącz akcelerację sprzętową, możesz użyć funkcji android:hardwareAccelerated dla atrybutu <application>. oraz <activity> elementów w: AndroidManifest.xml. Poniższy przykład umożliwia włączenie sprzętu akceleracja dla całej aplikacji, ale wyłącza ją w przypadku jednej operacji:

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

Zobacz akcelerację sprzętową tutaj informacje na temat opcji sterowania akceleracją sprzętową. Pamiętaj, że nie można włączyć akceleracji sprzętowej w przypadku pojedynczych wyświetleń reklamy, jest wyłączona, więc sama aktywność musi mieć włączoną akcelerację sprzętową.

Ręczne liczenie wyświetleń

Ręczne liczenie wyświetleń jest zgodne tylko w przypadku sprzedaży bezpośredniej i autoreklam kampanie z kreacjami trafikowanymi bezpośrednio w usłudze Ad Manager. Nie powinno być używane na potrzeby reklam zapasowych lub reklam w sieciach innych firm. Więcej informacji znajdziesz w sekcji Zliczanie wyświetleń i kliknięć.

Możesz ręcznie wysyłać pingi wyświetleń do Ad Managera, jeśli masz specjalne określając, kiedy należy zarejestrować wyświetlenie. Aby to zrobić, włącz AdManagerAdRequest – wyświetlenia ręczne przed wczytaniem reklamy:

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

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

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

{ ad_view }.recordManualImpression();

AdManagerAdView.recordManualImpression()

Zdarzenia w aplikacjach

Zdarzenia w aplikacji pozwalają tworzyć reklamy, które mogą wysyłać komunikaty do kodu aplikacji. Aplikacja mogą podejmować działania na podstawie tych komunikatów.

Możesz nasłuchiwać zdarzeń Ad Managera w aplikacjach za pomocą narzędzia AppEventListener. Te zdarzenia mogą wystąpić w dowolnym momencie cyklu życia reklamy, nawet przed Funkcja onAdLoaded() jest wywoływana.

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

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

Funkcja void onAppEvent(String name, String info) jest wywoływana, gdy wystąpi zdarzenie w aplikacji. w reklamie. Ten interfejs może zostać wdrożony przez aktywność lub inne obiekt:

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 przekazana do AdManagerAdView:

AdManagerAdView.setAppEventListener(this);

AdManagerAdView.appEventListener = this

Oto przykład, który 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 odpowiednia kreacja wysyłająca komunikaty o zdarzeniach w aplikacji kolorowych do Detektor:

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

W przykładzie Zdarzenia w aplikacji z Ad Managera znajdziesz przykład implementacji zdarzeń w aplikacji w interfejsie Aplikacja w wersji demonstracyjnej interfejsu API.

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, które są początkowo wyświetlane jako większe z nakładką, z przyciskiem do zwijania reklamy do mniejszego rozmiaru. Warto z niej korzystać aby jeszcze bardziej zoptymalizować skuteczność. Więcej informacji znajdziesz w artykule o zwijanych banerach reklamowych.

Wbudowane banery adaptacyjne

Śródtekstowe banery adaptacyjne są większe i wyższe niż zakotwiczone banery adaptacyjne. banerów. Mają zmienną wysokość i równą wysokość ekranu urządzenia. Wbudowane banery adaptacyjne są zalecane zamiast zakotwiczonych banerów adaptacyjnych w przypadku: które umieszczają banery reklamowe w treściach przewijanych. Zobacz Wbudowane reklamy adaptacyjne banerów .

Przeglądaj inne tematy

• Prywatność użytkowników
• Optymalizacja inicjowania i wczytywania reklam pakietu SDK (wersja beta)