Używanie niestandardowych formatów reklam natywnych

Wybierz platformę: Android Android iOS

Oprócz formatów natywnych zdefiniowanych przez system wydawcy Ad Managera mogą tworzyć własne formaty reklam natywnych, definiując niestandardowe listy komponentów. Są to niestandardowe formaty reklam natywnych, których można używać w przypadku reklam z rezerwacji. Umożliwia to wydawcom przekazywanie do aplikacji dowolnych danych strukturalnych. Te reklamy są reprezentowane przez NativeCustomFormatAd obiekt.

Uwaga: Klasa NativeCustomFormatAd nie obsługuje odbierania obiektu ResponseInfo ani pakietu extras.

Wczytywanie niestandardowych formatów reklam natywnych

Z tego przewodnika dowiesz się, jak wczytywać i wyświetlać niestandardowe formaty reklam natywnych.

Wczytywanie niestandardowej reklamy natywnej

Podobnie jak reklamy natywne, niestandardowe formaty reklam natywnych są wczytywane za pomocą klasy AdLoader:

Java

AdLoader adLoader = new AdLoader.Builder(this, "/21775744923/example/native")
    .forCustomFormatAd("12387226",
        new NativeCustomFormatAd.OnCustomFormatAdLoadedListener() {
          @Override
          public void onCustomFormatAdLoaded(NativeCustomFormatAd ad) {
            // Show the custom format and record an impression.
          }
        },
        new NativeCustomFormatAd.OnCustomClickListener() {
          @Override
          public void onCustomClick(NativeCustomFormatAd ad, String s) {
            // Handle the click action
          }
        })
    .forCustomFormatAd("12406343",
        new NativeCustomFormatAd.OnCustomFormatAdLoadedListener() {
          @Override
          public void onCustomFormatAdLoaded(NativeCustomFormatAd ad) {
            // Show the custom format and record an impression.
          }
        },
        new NativeCustomFormatAd.OnCustomClickListener() {
          @Override
          public void onCustomClick(NativeCustomFormatAd ad, String s) {
            // Handle the click action
          }
        })
    .build();

Kotlin

val adLoader = AdLoader.Builder(this, "/21775744923/example/native")
  .forCustomFormatAd(
    "12387226",
    { customFormatAd ->
      // Show the custom format and record an impression.
    },
    { customFormatAd, s ->
      // Handle the click action
    })
  .forCustomFormatAd(
    "12406343",
    { customFormatAd ->
      // Show the custom format and record an impression.
    },
    { customFormatAd, s ->
      // Handle the click action
    })
  .build()

Metoda forCustomFormatAd konfiguruje AdLoader tak, aby żądał niestandardowych formatów reklam natywnych. Możesz wywołać tę metodę kilka razy w przypadku różnych identyfikatorów formatów niestandardowych. Metoda przyjmuje te parametry:

• Identyfikator niestandardowego formatu reklamy natywnej, o który ma poprosić AdLoader. Każdy niestandardowy format reklamy natywnej ma powiązany z nim identyfikator. Ten parametr wskazuje, o jaki format ma poprosić AdLoader.
• OnCustomFormatAdLoadedListener , który ma zostać wywołany, gdy reklama zostanie wczytana.
• Opcjonalny OnCustomClickListener , który ma zostać wywołany, gdy użytkownik kliknie reklamę. Więcej informacji o tym detektorze znajdziesz w sekcji „Obsługa kliknięć i wyświetleń”.

Ponieważ jedną jednostkę reklamową można skonfigurować tak, aby wyświetlała więcej niż 1 format kreacji, metodę forCustomFormatAd można wywołać kilka razy z unikalnymi identyfikatorami formatów, aby przygotować moduł wczytywania reklam na więcej niż 1 możliwy niestandardowy format reklamy natywnej.

Uwaga: forNativeAd i forCustomFormatAd mogą być używane jednocześnie z jednym AdLoader, jeśli masz jednostkę reklamową skonfigurowaną tak, aby wyświetlała kilka formatów reklam.

Identyfikator niestandardowego formatu reklamy natywnej

Identyfikator formatu używany do identyfikowania niestandardowego formatu reklamy natywnej znajdziesz w interfejsie Ad Managera w sekcji Natywne w menu Wyświetlanie:

Każdy identyfikator niestandardowego formatu reklamy natywnej jest wyświetlany obok jego nazwy. Kliknięcie jednej z nazw powoduje przejście do ekranu szczegółów, na którym wyświetlają się informacje o polach formatu:

W tym miejscu można dodawać, edytować i usuwać poszczególne pola. Zwróć uwagę na nazwę każdego zasobu. Nazwa jest kluczem używanym do pobierania danych każdego komponentu podczas wyświetlania niestandardowego formatu reklamy natywnej.

Wyświetlanie niestandardowych formatów reklam natywnych

Niestandardowe formaty reklam natywnych różnią się od formatów zdefiniowanych przez system tym, że wydawcy mogą definiować własną listę komponentów, które składają się na reklamę. Dlatego proces wyświetlania różni się od formatów zdefiniowanych przez system na kilka sposobów:

1. Komponenty tekstowe i graficzne są dostępne za pomocą metod pobierających getText() i getImage(), które przyjmują nazwę pola jako parametr.
2. Ponieważ nie ma dedykowanej klasy ViewGroup, którą można zarejestrować w Google, musisz ręcznie rejestrować wyświetlenia i kliknięcia.
3. Niestandardowa reklama natywna ma treść multimedialną null, jeśli nie zawiera komponentu wideo.

Oto przykładowa funkcja, która wyświetla NativeCustomFormatAd:

Java

public void displayCustomFormatAd (ViewGroup parent,
                                     NativeCustomFormatAd customFormatAd) {
    // Inflate a layout and add it to the parent ViewGroup.
    LayoutInflater inflater = (LayoutInflater) parent.getContext()
            .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    View adView = inflater.inflate(R.layout.custom_format_ad, parent);

    // Locate the TextView that will hold the value for "Headline" and
    // set its text.
    TextView myHeadlineView = (TextView) adView.findViewById(R.id.headline);
    myHeadlineView.setText(customFormatAd.getText("Headline"));

    // Locate the ImageView that will hold the value for "MainImage" and
    // set its drawable.
    Button myMainImageView = (ImageView) adView.findViewById(R.id.main_image);
    myMainImageView.setImageDrawable(
            customFormatAd.getImage("MainImage").getDrawable());

    ...
    // Continue locating views and displaying assets until finished.
    ...
}

Kotlin

public fun displayCustomFormatAd (parent: ViewGroup,
                                customFormatAd: NativeCustomFormatAd) {
    val adView = layoutInflater
            .inflate(R.layout.ad_simple_custom_format, null)

    val myHeadlineView = adView.findViewById<TextView>(R.id.headline)
    myHeadlineView.setText(customFormatAd.getText("Headline"));

    // Locate the ImageView that will hold the value for "MainImage" and
    // set its drawable.
    val myMainImageView = adView.findViewById(R.id.main_image);
    myMainImageView.setImageDrawable(
            customFormatAd.getImage("MainImage").drawable);

    ...
    // Continue locating views and displaying assets until finished.
    ...
}

Natywna kreacja wideo w niestandardowych formatach reklam natywnych

Podczas tworzenia formatu niestandardowego, możesz sprawić, że będzie on kwalifikował się do wyświetlania reklam wideo.

W implementacji aplikacji możesz użyć NativeCustomFormatAd.getMediaContent() aby uzyskać treść multimedialną. Następnie wywołaj setMediaContent() , aby ustawić treść multimedialną w widoku multimediów. Jeśli reklama ma treść multimedialną null, przygotuj alternatywne plany wyświetlania reklamy bez filmu.

Poniższy przykład sprawdza, czy reklama zawiera treść wideo, i wyświetla obraz, jeśli film jest niedostępny:

Java

// Called when a custom native ad loads.
@Override
public void onCustomFormatAdLoaded(final NativeCustomFormatAd ad) {

  MediaContent mediaContent = ad.getMediaContent();

  // Assumes you have a FrameLayout in your view hierarchy with the ID media_placeholder.
  FrameLayout mediaPlaceholder = (FrameLayout) findViewById(R.id.media_placeholder);

  // Apps can check the MediaContent's hasVideoContent property to determine if the
  // NativeCustomFormatAd has a video asset.
  if (mediaContent != null && mediaContent.hasVideoContent()) {
    MediaView mediaView = new MediaView(mediaPlaceholder.getContext());
    mediaView.setMediaContent(mediaContent);
    mediaPlaceholder.addView(mediaView);

    // Create a new VideoLifecycleCallbacks object and pass it to the VideoController. The
    // VideoController will call methods on this object when events occur in the video
    // lifecycle.
    VideoController vc = mediaContent.getVideoController();
    vc.setVideoLifecycleCallbacks(
        new VideoController.VideoLifecycleCallbacks() {
          @Override
          public void onVideoEnd() {
            // Publishers should allow native ads to complete video playback before
            // refreshing or replacing them with another ad in the same UI location.
            super.onVideoEnd();
          }
        });
  } else {
    ImageView mainImage = new ImageView(this);
    mainImage.setAdjustViewBounds(true);
    mainImage.setImageDrawable(ad.getImage("MainImage").getDrawable());
    mediaPlaceholder.addView(mainImage);
    mainImage.setOnClickListener(
        new View.OnClickListener() {
          @Override
          public void onClick(View view) {
            ad.performClick("MainImage");
          }
        });
  }
}

Kotlin

// Called when a custom native ad loads.
NativeCustomFormatAd.OnCustomFormatAdLoadedListener { ad ->

  val mediaContent = ad.mediaContent

  // Apps can check the MediaContent's hasVideoContent property to determine if the
  // NativeCustomFormatAd has a video asset.
  if (mediaContent != null && mediaContent.hasVideoContent()) {
    val mediaView = MediaView(mediaPlaceholder.getContest())
    mediaView.mediaContent = mediaContent

    val videoController = mediaContent.videoController

    // Create a new VideoLifecycleCallbacks object and pass it to the VideoController. The
    // VideoController will call methods on this object when events occur in the video
    // lifecycle.
    if (videoController != null) {
      videoController.videoLifecycleCallbacks =
        object : VideoController.VideoLifecycleCallbacks() {
          override fun onVideoEnd() {
            // Publishers should allow native ads to complete video playback before refreshing
            // or replacing them with another ad in the same UI location.
            super.onVideoEnd()
          }
        }
    }
  } else {
    val mainImage = ImageView(this)
    mainImage.adjustViewBounds = true
    mainImage.setImageDrawable(ad.getImage("MainImage")?.drawable)

    mainImage.setOnClickListener { ad.performClick("MainImage") }
    customTemplateBinding.simplecustomMediaPlaceholder.addView(mainImage)
  }
}

Pobierz przykład renderowania niestandardowego w Ad Managerze , aby zobaczyć działający przykład natywnej kreacji wideo.

Więcej informacji o tym, jak dostosować wyświetlanie filmu w niestandardowej reklamie natywnej, znajdziesz w artykule Reklamy wideo.

Renderowanie ikony Informacja

W ramach wspierania aktu o usługach cyfrowych, reklamy z rezerwacji wyświetlane w Europejskim Obszarze Gospodarczym (EOG) muszą zawierać ikonę Informacja i link do strony „O tej reklamie” w Google. Implementując niestandardowe reklamy natywne, odpowiadasz za renderowanie ikony Informacja. Zalecamy podjęcie kroków w celu renderowania i ustawienia detektora kliknięć ikony Informacja podczas renderowania głównych komponentów reklamy.

W poniższym przykładzie zakłada się, że w hierarchii widoków zdefiniowano element <ImageView />, który będzie zawierał logo Informacja.

**Ważne:** ustaw ikonę Informacja o wymiarach co najmniej 15 x 15 pikseli.

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android">
    <ImageView
        android:id="@+id/adChoices"
        android:layout_width="15dp"
        android:layout_height="15dp"
        android:adjustViewBounds="true"
        android:contentDescription="AdChoices icon." />
</LinearLayout>

Poniższe przykłady renderują ikonę Informacja i konfigurują odpowiednie działanie po kliknięciu.

Java

private AdSimpleCustomTemplateBinding customTemplateBinding;

private void populateAdView(final NativeCustomFormatAd nativeCustomFormatAd) {
  // Render the AdChoices icon.
  String adChoicesKey = NativeAdAssetNames.ASSET_ADCHOICES_CONTAINER_VIEW;
  NativeAd.Image adChoicesAsset = nativeCustomFormatAd.getImage(adChoicesKey);
  if (adChoicesAsset == null) {
    customTemplateBinding.adChoices.setVisibility(View.GONE);
  } else {
    customTemplateBinding.adChoices.setVisibility(View.VISIBLE);
    customTemplateBinding.adChoices.setImageDrawable(adChoicesAsset.getDrawable());

    // Enable clicks on AdChoices.
    customTemplateBinding.adChoices.setOnClickListener(
        new View.OnClickListener() {
          @Override
          public void onClick(View v) {
            nativeCustomFormatAd.performClick(adChoicesKey);
          }
        });
  }
  ...
}

Kotlin

private lateinit var customTemplateBinding: AdSimpleCustomTemplateBinding

private fun populateAdView(nativeCustomFormatAd: NativeCustomFormatAd) {
  // Render the AdChoices icon.
  val adChoicesKey = NativeAdAssetNames.ASSET_ADCHOICES_CONTAINER_VIEW
  val adChoicesAsset = nativeCustomFormatAd.getImage(adChoicesKey)
  if (adChoicesAsset == null) {
    customTemplateBinding.adChoices.visibility = View.GONE
  } else {
    customTemplateBinding.adChoices.setImageDrawable(adChoicesAsset.drawable)
    customTemplateBinding.adChoices.visibility = View.VISIBLE

    // Enable clicks on AdChoices.
    customTemplateBinding.adChoices.setOnClickListener {
      nativeCustomFormatAd.performClick(adChoicesKey)
    }
  }
  ...
}

Ważna informacja:jeśli używasz opcji Kontrola pobierania obrazów aby żądać tylko adresów URL obrazów, komponent Informacja będzie respektować to ustawienie i zwracać tylko adres URL obrazu.

Rejestrowanie wyświetleń i raportowanie kliknięć

Twoja aplikacja odpowiada za rejestrowanie wyświetleń i raportowanie zdarzeń kliknięć do Google Mobile Ads SDK.

Rejestrowanie wyświetleń

Aby zarejestrować wyświetlenie niestandardowej reklamy natywnej, wywołaj metodę recordImpression() reklamy:

myCustomFormatAd.recordImpression();

Jeśli aplikacja przypadkowo wywoła tę metodę 2 razy w przypadku tej samej reklamy, pakiet SDK automatycznie uniemożliwi zarejestrowanie zduplikowanego wyświetlenia w przypadku pojedynczego żądania.

Raportowanie kliknięć

Aby poinformować pakiet SDK o kliknięciu widoku komponentu, wywołaj metodę performClick() reklamy. Podaj nazwę klikniętego komponentu, używając tego samego ciągu znaków, który został zdefiniowany w interfejsie Ad Managera.

myCustomFormatAd.performClick("MainImage");

Pamiętaj, że nie musisz wywoływać tej metody w przypadku każdego widoku powiązanego z reklamą. Jeśli masz inne pole o nazwie „Podpis”, które ma być wyświetlane, ale nie ma być klikane przez użytkownika, aplikacja nie musi wywoływać metody performClick w przypadku tego widoku komponentu.

Reagowanie na niestandardowe działania po kliknięciu

Gdy klikniesz reklamę w formacie niestandardowym, pakiet SDK może zareagować na 3 sposoby, w tej kolejności:

1. Wywoła OnCustomClickListener, jeśli został podany.
2. W przypadku każdego adresu URL linku bezpośredniego reklamy spróbuje znaleźć moduł rozpoznawania treści i uruchomić pierwszy, który się rozwiąże.
3. Otworzy przeglądarkę i przejdzie do docelowego adresu URL reklamy.

Aby zaimplementować niestandardowe działanie po kliknięciu, podaj OnCustomClickListener:

Java

AdLoader adLoader = new AdLoader.Builder(context, "/21775744923/example/native")
    .forCustomFormatAd("10063170",
      new NativeCustomFormatAd.OnCustomFormatAdLoadedListener() {
        // Display the ad.
      },
      new NativeCustomFormatAd.OnCustomClickListener() {
          @Override
          public void onCustomClick(NativeCustomFormatAd ad, String assetName) {
            Log.i("MyApp", "A custom click just happened for " + assetName + "!");
          }
      }).build();

Kotlin

val adLoader = AdLoader.Builder(this, "/21775744923/example/native")
    .forCustomFormatAd("10063170",
        { ad ->
            // Display the ad.
        },
        { ad, assetName ->
                Log.i("MyApp", "A custom click just happened for $assetName!")
    }).build()

Na początku może się wydawać dziwne, że istnieją niestandardowe detektory kliknięć. W końcu aplikacja właśnie poinformowała pakiet SDK o kliknięciu, więc dlaczego pakiet SDK miałby to zgłaszać aplikacji?

Ten przepływ informacji jest przydatny z kilku powodów, ale najważniejsze jest to, że umożliwia pakietowi SDK kontrolowanie reakcji na kliknięcie. Może on automatycznie wysyłać pingi do linków monitorujących firm zewnętrznych, które zostały ustawione dla kreacji, i wykonywać inne zadania w tle bez dodatkowego kodu.