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 pozostają w tekście podczas przewijania strony. 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:

/21775744923/example/adaptive-banner

Jest on specjalnie skonfigurowany tak, aby zwracać reklamy testowe w przypadku każdego żądania. Możesz go używać w swoich 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 widoku reklamy AdManager do układu

Pierwszym krokiem do wyświetlenia banera jest umieszczenie AdManagerAdView w układzie aplikacji:

// 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);
MyActivity.java

// Create a new ad view.
val adView = AdManagerAdView(this)
adView.adUnitId = AD_UNIT_ID
adView.setAdSize(adSize)
this.adView = adView

// Replace ad container with new ad view.
binding.adViewContainer.removeAllViews()
binding.adViewContainer.addView(adView)
MyActivity.kt

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

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

// Start loading the ad in the background.
val adRequest = AdManagerAdRequest.Builder().build()
adView.loadAd(adRequest)
MyActivity.kt

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 przesłać nowe żądanie.

Znakomicie. Twoja aplikacja jest teraz gotowa do wyświetlania reklam typu baner.

Zdarzenia reklamowe

adView.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.
    }
});

adView.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, które można zastąpić w AdListener, odpowiada zdarzeniu w cyklu życia reklamy.

Sprzętowa akceleracja 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łączyć akcelerację sprzętową, możesz użyć atrybutu android:hardwareAccelerated w elementach <application> i <activity> w pliku 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>

Więcej informacji o opcjach sterowania akceleracją sprzętową znajdziesz w przewodniku na ten temat. Pamiętaj, że nie można włączyć akceleracji sprzętowej poszczególnych wyświetleń reklamy, jeśli 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. Zdarzenia te 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 aplikacji. 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 przekazano 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>

Aby zobaczyć przykład implementacji zdarzeń w aplikacjach w aplikacji demonstracyjnej interfejsu API, zapoznaj się z artykułem Zdarzenia w aplikacji w Ad Managerze – przykład.

Java Kotlin

Dodatkowe materiały

Przykłady w GitHubie

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

• Demonstracja 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 pakietu SDK i wczytywania reklam (wersja beta)