Ta strona została przetłumaczona przez Cloud Translation API.

Zdarzenia niestandardowe w reklamach natywnych

Wymagania wstępne

Dokończ konfigurację zdarzeń niestandardowych.

Wysyłanie żądania reklamy natywnej

Po dotarciu do elementu zamówienia zdarzenia niestandardowego w łańcuchu zapośredniczenia kaskadowegothe loadNativeAd:adConfiguration:completionHandler: method zostaje wywołana z nazwą klasy podaną podczas tworzenia zdarzenia niestandardowego. W tym przypadku jest to metoda SampleCustomEvent, która wywołuje metodęthe loadNativeAd:adConfiguration:completionHandler: method in SampleCustomEventNative.

Aby wysłać żądanie reklamy natywnej, utwórz lub zmodyfikuj klasę, która implementuje GADMediationAdapter i loadNativeAd:adConfiguration:completionHandler:. Jeśli klasa z rozszerzeniem GADMediationAdapter już istnieje, zaimplementuj w niej właściwość loadNativeAd:adConfiguration:completionHandler:. Dodatkowo utwórz nową klasę do zaimplementowania GADMediationNativeAd.

W naszym przykładzie zdarzenia niestandardowego SampleCustomEvent implementuje tagthe GADMediationAdapter interface , a potem przekazuje dostęp do funkcjiSampleCustomEventNative.

Swift

import GoogleMobileAds

class SampleCustomEvent: NSObject, GADMediationAdapter {

  fileprivate var nativeAd: SampleCustomEventNativeAd?

  func loadNativeAd(
    for adConfiguration: GADMediationNativeAdConfiguration,
    completionHandler: @escaping GADMediationNativeAdLoadCompletionHandler
  ) {
    self.nativeAd = SampleCustomEventNativeAd()
    self.nativeAd?.loadNativeAd(
      for: adConfiguration, completionHandler: completionHandler)
  }
}

Objective-C

#import "SampleCustomEvent.h"

@implementation SampleCustomEvent

SampleCustomEventNativeAd *sampleNativeAd;

- (void)loadNativeAdForAdConfiguration:
            (GADMediationNativeAdConfiguration *)adConfiguration
                     completionHandler:
                         (GADMediationNativeAdLoadCompletionHandler)
                             completionHandler {
  sampleNative = [[SampleCustomEventNativeAd alloc] init];
  [sampleNative loadNativeAdForAdConfiguration:adConfiguration
                             completionHandler:completionHandler];
}

SampleCustomEventNative jest odpowiedzialny za następujące zadania:

Wczytuję reklamę natywną
Wdrożenie funkcji GADMediationNativeAd protocol
Odbieranie i raportowanie wywołań zwrotnych zdarzeń reklamowych do pakietu SDK do reklam mobilnych Google

Opcjonalny parametr zdefiniowany w interfejsie AdMob jest uwzględniany w konfiguracji reklamy. Dostęp do parametru możesz uzyskać poprzez adConfiguration.credentials.settings[@"parameter"]. Ten parametr to zazwyczaj identyfikator jednostki reklamowej, którego pakiet SDK sieci reklamowej wymaga podczas inicjowania obiektu reklamowego.

Swift

class SampleCustomEventNativeAd: NSObject, GADMediationNativeAd {
  /// The Sample Ad Network native ad.
  var nativeAd: SampleNativeAd?

  /// The ad event delegate to forward ad rendering events to the Google Mobile
  /// Ads SDK.
  var delegate: GADMediationNativeAdEventDelegate?

  /// Completion handler called after ad load
  var completionHandler: GADMediationNativeLoadCompletionHandler?

  func loadNativeAd(
    for adConfiguration: GADMediationNativeAdConfiguration,
    completionHandler: @escaping GADMediationNativeLoadCompletionHandler
  ) {
    let adLoader = SampleNativeAdLoader()
    let sampleRequest = SampleNativeAdRequest()

    // The Google Mobile Ads SDK requires the image assets to be downloaded
    // automatically unless the publisher specifies otherwise by using the
    // GADNativeAdImageAdLoaderOptions object's disableImageLoading property. If
    // your network doesn't have an option like this and instead only ever
    // returns URLs for images (rather than the images themselves), your adapter
    // should download image assets on behalf of the publisher. This should be
    // done after receiving the native ad object from your network's SDK, and
    // before calling the connector's adapter:didReceiveMediatedNativeAd: method.
    sampleRequest.shouldDownloadImages = true
    sampleRequest.preferredImageOrientation = NativeAdImageOrientation.any
    sampleRequest.shouldRequestMultipleImages = false
    let options = adConfiguration.options
    for loaderOptions: GADAdLoaderOptions in options {
      if let imageOptions = loaderOptions as? GADNativeAdImageAdLoaderOptions {
        sampleRequest.shouldRequestMultipleImages =
          imageOptions.shouldRequestMultipleImages
        // If the GADNativeAdImageAdLoaderOptions' disableImageLoading property is
        // YES, the adapter should send just the URLs for the images.
        sampleRequest.shouldDownloadImages = !imageOptions.disableImageLoading
      } else if let mediaOptions = loaderOptions
        as? GADNativeAdMediaAdLoaderOptions
      {
        switch mediaOptions.mediaAspectRatio {
        case GADMediaAspectRatio.landscape:
          sampleRequest.preferredImageOrientation =
            NativeAdImageOrientation.landscape
        case GADMediaAspectRatio.portrait:
          sampleRequest.preferredImageOrientation =
            NativeAdImageOrientation.portrait
        default:
          sampleRequest.preferredImageOrientation = NativeAdImageOrientation.any
        }
      }
    }
    // This custom event uses the server parameter to carry an ad unit ID, which
    // is the most common use case.
    adLoader.delegate = self
    adLoader.adUnitID =
      adConfiguration.credentials.settings["parameter"] as? String
    self.completionHandler = completionHandler
    adLoader.fetchAd(sampleRequest)
  }
}

Objective-C

#import "SampleCustomEventNativeAd.h"

@interface SampleCustomEventNativeAd () <SampleNativeAdDelegate,
                                         GADMediationNativeAd> {
  /// The sample native ad.
  SampleNativeAd *_nativeAd;

  /// The completion handler to call when the ad loading succeeds or fails.
  GADMediationNativeLoadCompletionHandler _loadCompletionHandler;

  /// The ad event delegate to forward ad rendering events to the Google Mobile
  /// Ads SDK.
  id<GADMediationNativeAdEventDelegate> _adEventDelegate;
}
@end

- (void)loadNativeAdForAdConfiguration:
            (GADMediationNativeAdConfiguration *)adConfiguration
                     completionHandler:(GADMediationNativeLoadCompletionHandler)
                                           completionHandler {
  __block atomic_flag completionHandlerCalled = ATOMIC_FLAG_INIT;
  __block GADMediationNativeLoadCompletionHandler originalCompletionHandler =
      [completionHandler copy];

  _loadCompletionHandler = ^id<GADMediationNativeAdEventDelegate>(
      _Nullable id<GADMediationNativeAd> ad, NSError *_Nullable error) {
    // Only allow completion handler to be called once.
    if (atomic_flag_test_and_set(&completionHandlerCalled)) {
      return nil;
    }

    id<GADMediationNativeAdEventDelegate> delegate = nil;
    if (originalCompletionHandler) {
      // Call original handler and hold on to its return value.
      delegate = originalCompletionHandler(ad, error);
    }

    // Release reference to handler. Objects retained by the handler will also
    // be released.
    originalCompletionHandler = nil;

    return delegate;
  };

  SampleNativeAdLoader *adLoader = [[SampleNativeAdLoader alloc] init];
  SampleNativeAdRequest *sampleRequest = [[SampleNativeAdRequest alloc] init];

  // The Google Mobile Ads SDK requires the image assets to be downloaded
  // automatically unless the publisher specifies otherwise by using the
  // GADNativeAdImageAdLoaderOptions object's disableImageLoading property. If
  // your network doesn't have an option like this and instead only ever returns
  // URLs for images (rather than the images themselves), your adapter should
  // download image assets on behalf of the publisher. This should be done after
  // receiving the native ad object from your network's SDK, and before calling
  // the connector's adapter:didReceiveMediatedNativeAd: method.
  sampleRequest.shouldDownloadImages = YES;

  sampleRequest.preferredImageOrientation = NativeAdImageOrientationAny;
  sampleRequest.shouldRequestMultipleImages = NO;
  sampleRequest.testMode = adConfiguration.isTestRequest;

  for (GADAdLoaderOptions *loaderOptions in adConfiguration.options) {
    if ([loaderOptions isKindOfClass:[GADNativeAdImageAdLoaderOptions class]]) {
      GADNativeAdImageAdLoaderOptions *imageOptions =
          (GADNativeAdImageAdLoaderOptions *)loaderOptions;
      sampleRequest.shouldRequestMultipleImages =
          imageOptions.shouldRequestMultipleImages;

      // If the GADNativeAdImageAdLoaderOptions' disableImageLoading property is
      // YES, the adapter should send just the URLs for the images.
      sampleRequest.shouldDownloadImages = !imageOptions.disableImageLoading;
    } else if ([loaderOptions
                   isKindOfClass:[GADNativeAdMediaAdLoaderOptions class]]) {
      GADNativeAdMediaAdLoaderOptions *mediaOptions =
          (GADNativeAdMediaAdLoaderOptions *)loaderOptions;
      switch (mediaOptions.mediaAspectRatio) {
        case GADMediaAspectRatioLandscape:
          sampleRequest.preferredImageOrientation =
              NativeAdImageOrientationLandscape;
          break;
        case GADMediaAspectRatioPortrait:
          sampleRequest.preferredImageOrientation =
              NativeAdImageOrientationPortrait;
          break;
        default:
          sampleRequest.preferredImageOrientation = NativeAdImageOrientationAny;
          break;
      }
    } else if ([loaderOptions isKindOfClass:[GADNativeAdViewAdOptions class]]) {
      _nativeAdViewAdOptions = (GADNativeAdViewAdOptions *)loaderOptions;
    }
  }

  // This custom event uses the server parameter to carry an ad unit ID, which
  // is the most common use case.
  NSString *adUnit = adConfiguration.credentials.settings[@"parameter"];
  adLoader.adUnitID = adUnit;
  adLoader.delegate = self;

  [adLoader fetchAd:sampleRequest];
}

Niezależnie od tego, czy reklama zostanie pobrana czy wystąpi błąd, wywołaj GADMediationNativeAdLoadCompletionHandler. Jeśli wszystko zadziała, przejdź przez klasę, która implementuje GADMediationNativeAd z wartością nil dla parametru błędu. W przypadku niepowodzenia prześlij podany błąd.

Zwykle metody te są implementowane w wywołaniach zwrotnych z zewnętrznego pakietu SDK zaimplementowanego przez adapter. W tym przykładzie przykładowy pakiet SDK zawiera element SampleNativeAdDelegate ze odpowiednimi wywołaniami zwrotnymi:

Swift

func adLoader(
  _ adLoader: SampleNativeAdLoader, didReceive nativeAd: SampleNativeAd
) {
  extraAssets = [
    SampleCustomEventConstantsSwift.awesomenessKey: nativeAd.degreeOfAwesomeness
      ?? ""
  ]

  if let image = nativeAd.image {
    images = [GADNativeAdImage(image: image)]
  } else {
    let imageUrl = URL(fileURLWithPath: nativeAd.imageURL)
    images = [GADNativeAdImage(url: imageUrl, scale: nativeAd.imageScale)]
  }
  if let mappedIcon = nativeAd.icon {
    icon = GADNativeAdImage(image: mappedIcon)
  } else {
    let iconURL = URL(fileURLWithPath: nativeAd.iconURL)
    icon = GADNativeAdImage(url: iconURL, scale: nativeAd.iconScale)
  }

  adChoicesView = SampleAdInfoView()
  self.nativeAd = nativeAd
  if let handler = completionHandler {
    delegate = handler(self, nil)
  }
}

func adLoader(
  _ adLoader: SampleNativeAdLoader,
  didFailToLoadAdWith errorCode: SampleErrorCode
) {
  let error =
    SampleCustomEventUtilsSwift.SampleCustomEventErrorWithCodeAndDescription(
      code: SampleCustomEventErrorCodeSwift
        .SampleCustomEventErrorAdLoadFailureCallback,
      description:
        "Sample SDK returned an ad load failure callback with error code: \(errorCode)"
    )
  if let handler = completionHandler {
    delegate = handler(nil, error)
  }
}

Objective-C

- (void)adLoader:(SampleNativeAdLoader *)adLoader
    didReceiveNativeAd:(SampleNativeAd *)nativeAd {
  if (nativeAd.image) {
    _images = @[ [[GADNativeAdImage alloc] initWithImage:nativeAd.image] ];
  } else {
    NSURL *imageURL = [[NSURL alloc] initFileURLWithPath:nativeAd.imageURL];
    _images = @[ [[GADNativeAdImage alloc] initWithURL:imageURL
                                                 scale:nativeAd.imageScale] ];
  }

  if (nativeAd.icon) {
    _icon = [[GADNativeAdImage alloc] initWithImage:nativeAd.icon];
  } else {
    NSURL *iconURL = [[NSURL alloc] initFileURLWithPath:nativeAd.iconURL];
    _icon = [[GADNativeAdImage alloc] initWithURL:iconURL
                                            scale:nativeAd.iconScale];
  }

  // The sample SDK provides an AdChoices view (SampleAdInfoView). If your SDK
  // provides image and click through URLs for its AdChoices icon instead of an
  // actual UIView, the adapter is responsible for downloading the icon image
  // and creating the AdChoices icon view.
  _adChoicesView = [[SampleAdInfoView alloc] init];
  _nativeAd = nativeAd;

  _adEventDelegate = _loadCompletionHandler(self, nil);
}

- (void)adLoader:(SampleNativeAdLoader *)adLoader
    didFailToLoadAdWithErrorCode:(SampleErrorCode)errorCode {
  NSError *error = SampleCustomEventErrorWithCodeAndDescription(
      SampleCustomEventErrorAdLoadFailureCallback,
      [NSString stringWithFormat:@"Sample SDK returned an ad load failure "
                                 @"callback with error code: %@",
                                 errorCode]);
  _adEventDelegate = _loadCompletionHandler(nil, error);
}

Mapowanie reklam natywnych

Różne pakiety SDK mają własne formaty reklam natywnych. Jeden z nich może zwracać obiekty, które zawierają pole „title”, a inny – „headline”. Poza tym metody śledzenia wyświetleń i przetwarzania kliknięć mogą być różne w zależności od pakietu SDK.

Aby rozwiązać te problemy, gdy zdarzenie niestandardowe otrzyma obiekt reklamy natywnej z zapośredniczonego pakietu SDK, powinno użyć klasy implementującej GADMediationNativeAd, np. SampleCustomEventNativeAd, aby „mapować” obiekt reklamy natywnej pakietu SDK zapośredniczonego pakietu SDK w taki sposób, aby odpowiadał interfejsowi oczekiwanemu przez pakiet SDK do reklam mobilnych Google.

Przyjrzymy się teraz bliżej szczegółów implementacji interfejsu SampleCustomEventNativeAd.

Przechowywanie mapowań

Oczekuje się, że GADMediationNativeAd wdroży określone właściwości zmapowane z właściwości innego pakietu SDK:

Swift

var nativeAd: SampleNativeAd?

var headline: String? {
  return nativeAd?.headline
}

var images: [GADNativeAdImage]?

var body: String? {
  return nativeAd?.body
}

var icon: GADNativeAdImage?

var callToAction: String? {
  return nativeAd?.callToAction
}

var starRating: NSDecimalNumber? {
  return nativeAd?.starRating
}

var store: String? {
  return nativeAd?.store
}

var price: String? {
  return nativeAd?.price
}

var advertiser: String? {
  return nativeAd?.advertiser
}

var extraAssets: [String: Any]? {
  return [
    SampleCustomEventConstantsSwift.awesomenessKey:
      nativeAd?.degreeOfAwesomeness
      ?? ""
  ]
}

var adChoicesView: UIView?

var mediaView: UIView? {
  return nativeAd?.mediaView
}

Objective-C

/// Used to store the ad's images. In order to implement the
/// GADMediationNativeAd protocol, we use this class to return the images
/// property.
NSArray<GADNativeAdImage *> *_images;

/// Used to store the ad's icon. In order to implement the GADMediationNativeAd
/// protocol, we use this class to return the icon property.
GADNativeAdImage *_icon;

/// Used to store the ad's ad choices view. In order to implement the
/// GADMediationNativeAd protocol, we use this class to return the adChoicesView
/// property.
UIView *_adChoicesView;

- (nullable NSString *)headline {
  return _nativeAd.headline;
}

- (nullable NSArray<GADNativeAdImage *> *)images {
  return _images;
}

- (nullable NSString *)body {
  return _nativeAd.body;
}

- (nullable GADNativeAdImage *)icon {
  return _icon;
}

- (nullable NSString *)callToAction {
  return _nativeAd.callToAction;
}

- (nullable NSDecimalNumber *)starRating {
  return _nativeAd.starRating;
}

- (nullable NSString *)store {
  return _nativeAd.store;
}

- (nullable NSString *)price {
  return _nativeAd.price;
}

- (nullable NSString *)advertiser {
  return _nativeAd.advertiser;
}

- (nullable NSDictionary<NSString *, id> *)extraAssets {
  return
      @{SampleCustomEventExtraKeyAwesomeness : _nativeAd.degreeOfAwesomeness};
}

- (nullable UIView *)adChoicesView {
  return _adChoicesView;
}

- (nullable UIView *)mediaView {
  return _nativeAd.mediaView;
}

- (BOOL)hasVideoContent {
  return self.mediaView != nil;
}

Niektóre sieci zapośredniczone mogą dostarczać dodatkowe komponenty poza tymi określonymi w pakiecie SDK do reklam mobilnych Google. Protokół GADMediationNativeAd zawiera metodę extraAssets, za pomocą której pakiet SDK do reklam mobilnych Google pobiera te „dodatkowe” zasoby z Twojego narzędzia do tworzenia map.

Komponenty z obrazem mapy

Mapowanie komponentów z obrazem jest bardziej skomplikowane niż mapowanie uproszczonych typów danych, takich jak NSString czy double. Obrazy mogą być pobierane automatycznie lub zwracane jako wartości adresów URL. Gęstość pikseli też może być różna.

Aby ułatwić Ci zarządzanie tymi szczegółami, pakiet SDK do reklam mobilnych Google udostępnia klasę GADNativeAdImage. Za pomocą tej klasy informacje o komponentach z obrazem (rzeczywiste obiekty UIImage czy tylko wartości NSURL) powinny być zwracane do pakietu SDK do reklam mobilnych Google.

Oto jak klasa mapper obsługuje tworzenie elementu GADNativeAdImage do przechowywania obrazu ikony:

Swift

if let image = nativeAd.image {
  images = [GADNativeAdImage(image: image)]
} else {
  let imageUrl = URL(fileURLWithPath: nativeAd.imageURL)
  images = [GADNativeAdImage(url: imageUrl, scale: nativeAd.imageScale)]
}

Objective-C

if (nativeAd.image) {
  _images = @[ [[GADNativeAdImage alloc] initWithImage:nativeAd.image] ];
} else {
  NSURL *imageURL = [[NSURL alloc] initFileURLWithPath:nativeAd.imageURL];
  _images = @[ [[GADNativeAdImage alloc] initWithURL:imageURL
                                               scale:nativeAd.imageScale] ];
}

Zdarzenia wyświetlenia i kliknięcia

Pakiet SDK do reklam mobilnych Google i pakiet zapośredniczony muszą wiedzieć, kiedy nastąpi wyświetlenie lub kliknięcie, ale tylko jeden pakiet SDK będzie śledzić te zdarzenia. Zdarzenia niestandardowe można stosować na 2 sposoby w zależności od tego, czy zapośredniczony pakiet SDK samodzielnie obsługuje śledzenie wyświetleń i kliknięć.

Śledzenie kliknięć i wyświetleń za pomocą pakietu SDK do reklam mobilnych Google

Jeśli zapośredniczony pakiet SDK nie wykonuje własnego śledzenia wyświetleń i kliknięć, ale umożliwia rejestrowanie kliknięć i wyświetleń, pakiet ten może śledzić te zdarzenia i powiadamiać adapter. GADMediationNativeAd protocol Udostępnia 2 metody: didRecordImpression: oraz didRecordClickOnAssetWithName:view:viewController: za pomocą zdarzeń niestandardowych, które mogą wywoływać odpowiednią metodę w zapośredniczonym obiekcie reklamy natywnej:

Swift

func didRecordImpression() {
  nativeAd?.recordImpression()
}

func didRecordClickOnAsset(
  withName assetName: GADUnifiedNativeAssetIdentifier,
  view: UIView,
  wController: UIViewController
) {
  nativeAd?.handleClick(on: view)
}

Objective-C

- (void)didRecordImpression {
  if (self.nativeAd) {
    [self.nativeAd recordImpression];
  }
}

- (void)didRecordClickOnAssetWithName:(GADUnifiedNativeAssetIdentifier)assetName
                                 view:(UIView *)view
                       viewController:(UIViewController *)viewController {
  if (self.nativeAd) {
    [self.nativeAd handleClickOnView:view];
  }
}

Klasa, która implementuje protokół GADMediationNativeAd protocol, zawiera odniesienie do obiektu reklamy natywnej przykładowego pakietu SDK, dlatego może wywołać w tym obiekcie odpowiednią metodę w celu zgłoszenia kliknięcia lub wyświetlenia. Pamiętaj, że metodadidRecordClickOnAssetWithName:view:viewController: przyjmuje jeden parametr: obiekt View odpowiadający komponentowi reklamy natywnej, który otrzymał kliknięcie.

Śledzenie kliknięć i wyświetleń za pomocą zapośredniczonego pakietu SDK

Niektóre pakiety SDK zapośredniczone mogą preferować samodzielne śledzenie kliknięć i wyświetleń. W takim przypadku zastosuj metody handlesUserClicks i handlesUserImpressions, jak pokazano w poniższym fragmencie. Zwracając parametr YES, wskazujesz, że zdarzenie niestandardowe bierze odpowiedzialność za śledzenie tych zdarzeń i powiadamia o nich pakiet SDK do reklam mobilnych Google.

Zdarzenia niestandardowe, które zastępują śledzenie kliknięć i wyświetleń, mogą używać komunikatu didRenderInView: do przekazywania widoku reklamy natywnej do obiektu reklamy natywnej pakietu SDK zapośredniczonego pakietu SDK, co umożliwia rzeczywiste śledzenie. Przykładowy pakiet SDK z naszego przykładowego projektu ze zdarzeniami niestandardowymi (z którego pobrano fragmenty kodu z tego przewodnika) nie korzysta z tej metody. Gdyby jednak tak się stało, kod zdarzenia niestandardowego wywołałby metodę setNativeAdView:view:, jak widać we fragmencie poniżej:

Swift

func handlesUserClicks() -> Bool {
  return true
}
func handlesUserImpressions() -> Bool {
  return true
}

func didRender(
  in view: UIView, clickableAssetViews: [GADNativeAssetIdentifier: UIView],
  nonclickableAssetViews: [GADNativeAssetIdentifier: UIView],
  viewController: UIViewController
) {
  // This method is called when the native ad view is rendered. Here you would pass the UIView
  // back to the mediated network's SDK.
  self.nativeAd?.setNativeAdView(view)
}

Objective-C

- (BOOL)handlesUserClicks {
  return YES;
}

- (BOOL)handlesUserImpressions {
  return YES;
}

- (void)didRenderInView:(UIView *)view
       clickableAssetViews:(NSDictionary<GADNativeAssetIdentifier, UIView *> *)
                               clickableAssetViews
    nonclickableAssetViews:(NSDictionary<GADNativeAssetIdentifier, UIView *> *)
                               nonclickableAssetViews
            viewController:(UIViewController *)viewController {
  // This method is called when the native ad view is rendered. Here you would
  // pass the UIView back to the mediated network's SDK. Playing video using
  // SampleNativeAd's playVideo method
  [_nativeAd setNativeAdView:view];
}

Przekierowywanie zdarzeń zapośredniczenia do pakietu SDK do reklam mobilnych Google

Gdy wywołasz GADMediationNativeLoadCompletionHandler z załadowaną reklamą, adapter może użyć zwróconego obiektu przekazywania GADMediationNativeAdEventDelegate, aby przekazać zdarzenia prezentacji z pakietu SDK firmy zewnętrznej do pakietu SDK do reklam mobilnych Google.

Ważne jest, aby zdarzenie niestandardowe przekazywało jak najwięcej takich wywołań zwrotnych, aby aplikacja otrzymywała równoważne zdarzenia z pakietu SDK do reklam mobilnych Google. Oto przykład użycia wywołań zwrotnych:

Na tym kończy się implementacja zdarzeń niestandardowych w przypadku reklam natywnych. Pełny przykład jest dostępny na GitHub.