דף זה תורגם על ידי Cloud Translation API.

אירועים מותאמים אישית של מודעות מותאמות

דרישות מוקדמות

השלם את ההגדרה של אירועים מותאמים אישית.

בקשת מודעה מותאמת

כשמגיעים לפריט של האירוע המותאם אישית בשרשרת לבחירת הרשת ב-Waterfall, המערכת מפעילה אתthe loadNativeAd:adConfiguration:completionHandler: method לפי שם המחלקה שסיפקתם כשיוצרים אירוע בהתאמה אישית. במקרה הזה, השיטה הזו היא ב-SampleCustomEvent, ואז קוראת ל-the loadNativeAd:adConfiguration:completionHandler: method ב- SampleCustomEventNative.

כדי לבקש מודעה מותאמת, עליכם ליצור או לשנות מחלקה שבה מוטמעות GADMediationAdapter ו-loadNativeAd:adConfiguration:completionHandler:. אם כבר קיימת מחלקה שמרחיבה את GADMediationAdapter, מטמיעים בה את loadNativeAd:adConfiguration:completionHandler:. בנוסף, צריך ליצור מחלקה חדשה כדי להטמיע את GADMediationNativeAd.

בדוגמה של האירוע בהתאמה אישית, SampleCustomEvent מטמיעthe GADMediationAdapter interface ואז מעניק גישה ל-SampleCustomEventNative.

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 אחראי על המשימות הבאות:

המודעה המותאמת בטעינה
הטמעה של GADMediationNativeAd protocol
קבלת קריאות חוזרות של אירועי מודעות ודיווח עליהן ל-Google Mobile Ads SDK

הפרמטר האופציונלי שמוגדר AdMob בממשק המשתמש כלול בהגדרות האישיות של המודעות. אפשר לגשת לפרמטר דרך adConfiguration.credentials.settings[@"parameter"]. הפרמטר הזה הוא בדרך כלל מזהה של יחידת מודעות שנדרש ל-SDK של רשת מודעות כשיוצרים אובייקט של מודעה.

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];
}

גם אם המודעה אוחזרה בהצלחה וגם אם מופיעה שגיאה, צריך לבצע קריאה ל-GADMediationNativeAdLoadCompletionHandler. במקרה של הצלחה, מעבירים את המחלקה שמטמיעה את GADMediationNativeAd עם הערך nil לפרמטר השגיאה. במקרה של כישלון, מעבירים את השגיאה שבה נתקלתם.

בדרך כלל, השיטות האלה מוטמעות בקריאות חוזרות מ-SDK של הצד השלישי שהמתאם מטמיע. בדוגמה הזו, ה-SDK לדוגמה כולל SampleNativeAdDelegate עם קריאה חוזרת (callback) רלוונטית:

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

מודעות מותאמות של מיפוי

לערכות SDK שונות יש פורמטים ייחודיים משלהן למודעות מותאמות. למשל, אחד יכול להחזיר אובייקטים שמכילים שדה "title", ואילו אובייקט אחר עשוי להכיל "כותרת". בנוסף, השיטות שמשמשות למעקב אחרי חשיפות ולעיבוד קליקים יכולות להשתנות מערכת SDK אחת לאחרת.

כדי לטפל בבעיות האלה, כשאירוע מותאם אישית מקבל אובייקט של מודעה מותאמת מה-SDK שלו בתהליך בחירת הרשת, יש להשתמש במחלקה שמוטמעת בה GADMediationNativeAd, כמו SampleCustomEventNativeAd, על מנת "למפות" את אובייקט המודעה המותאמת של ה-SDK שנמצא בתהליך בחירת הרשת, כך שיתאים לממשק הצפוי על ידי Google Mobile Ads SDK.

עכשיו נבחן מקרוב את פרטי ההטמעה של SampleCustomEventNativeAd.

אחסון המיפויים

GADMediationNativeAd צפוי להטמיע מאפיינים מסוימים שממופים ממאפיינים של 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;
}

חלק מהרשתות שמשתתפות בתהליך בחירת הרשת יכולות לספק נכסים נוספים, מעבר לאלה שהוגדרו ב-Google Mobile Ads SDK. הפרוטוקול GADMediationNativeAd כולל שיטה שנקראת extraAssets, שבה משתמש Google Mobile Ads SDK כדי לאחזר את הנכסים ה "נוספים" האלה מהממפה.

נכסי תמונות של מפות

מיפוי נכסי תמונות מורכב יותר ממיפוי של סוגי נתונים פשוטים יותר, כמו NSString או double. יכול להיות שהתמונות יורדו אוטומטית או שיוחזרו כערכי כתובות URL. גם דחיסות הפיקסלים שלהם עשויה להשתנות.

כדי לעזור לכם לנהל את הפרטים האלה, Google Mobile Ads SDK מספק את המחלקה GADNativeAdImage. באמצעות המחלקה הזו, צריך להחזיר ל-Google Mobile Ads SDK מידע על נכסי תמונות (בין אם מדובר באובייקטים מסוג UIImage בפועל או רק בערכי NSURL).

כך מחלקת הממפה מטפלת ביצירת GADNativeAdImage כדי להחזיק את תמונת הסמל:

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] ];
}

אירועי חשיפות וקליקים

גם Google Mobile Ads SDK וגם ה-SDK של תהליך בחירת הרשת צריכים לדעת מתי מתרחשים חשיפה או קליק, אבל רק ערכת SDK אחת צריכה לעקוב אחרי האירועים האלה. יש שתי גישות שונות שבהן ניתן להשתמש באירועים מותאמים אישית, בהתאם לשאלה האם ה-SDK המתווך תומך במעקב אחר חשיפות וקליקים בעצמו.

מעקב אחר קליקים וחשיפות באמצעות Google Mobile Ads SDK

אם ה-SDK של תהליך בחירת הרשת לא מבצע מעקב אחר חשיפות וקליקים משלו, אבל מספק שיטות לתיעוד קליקים וחשיפות, Google Mobile Ads SDK יכול לעקוב אחרי האירועים האלה ולהודיע למתאם. GADMediationNativeAd protocol כולל שתי שיטות: didRecordImpression: וגם didRecordClickOnAssetWithName:view:viewController: ניתן להטמיע אירועים מותאמים אישית כדי להפעיל את השיטה המתאימה באובייקט של המודעה המותאמת בתהליך בחירת הרשת:

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];
  }
}

מכיוון שהמחלקה שמטמיעה את GADMediationNativeAd protocol הפרוטוקול מכילה הפניה לאובייקט המודעה המותאמת של ה-SDK לדוגמה, היא יכולה לקרוא לשיטה המתאימה באובייקט הזה כדי לדווח על קליק או חשיפה. שימו לב שהשיטהdidRecordClickOnAssetWithName:view:viewController: מתייחסת לפרמטר יחיד: האובייקט View שתואם לנכס המודעה המותאמת שקיבל את הקליק.

מעקב אחר קליקים וחשיפות באמצעות ה-SDK בתהליך בחירת הרשת (Mediation)

בחלק מערכות ה-SDK שמשתתפות בתהליך בחירת הרשת מומלץ לעקוב בעצמן אחרי קליקים וחשיפות. במקרה כזה, עליכם להטמיע את השיטות handlesUserClicks ו-handlesUserImpressions כפי שהן מוצגות בקטע הקוד שבהמשך. החזרה YES מציינת שהמעקב אחרי האירועים האלה באחריות האירוע המותאם אישית, וה-Google Mobile Ads SDK יקבל הודעה על כך כשהאירועים האלה יתרחשו.

אירועים מותאמים אישית שמבטלים מעקב אחר קליקים וחשיפות יכולים להשתמש בהודעה didRenderInView: כדי להעביר את התצוגה של המודעה המותאמת לאובייקט המודעה המותאמת של ה-SDK בתהליך בחירת הרשת, וכך לאפשר ל-SDK בתהליך בחירת הרשת לבצע את המעקב בפועל. בערכת ה-SDK לדוגמה מהפרויקט לדוגמה של אירוע מותאם אישית (שממנו נלקחו קטעי הקוד של המדריך הזה) לא נעשה שימוש בגישה הזו. אם כן, קוד האירוע המותאם אישית יקרא לשיטה setNativeAdView:view: כפי שמוצג בקטע הקוד הבא:

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];
}

העברת אירועים של תהליך בחירת הרשת (Mediation) אל Google Mobile Ads SDK

אחרי שקוראים לפונקציה GADMediationNativeLoadCompletionHandler עם מודעה שנטענה, המתאם יכול להשתמש באובייקט בעל הגישה של GADMediationNativeAdEventDelegate שהוחזר כדי להעביר אירועי הצגה מה-SDK של הצד השלישי ל-Google Mobile Ads SDK.

חשוב שהאירוע המותאם אישית יעביר כמה שיותר קריאות חוזרות כאלה, כדי שהאפליקציה תקבל את האירועים המקבילים האלה מ-Google Mobile Ads SDK. דוגמה לשימוש בהתקשרות חזרה:

הפעולה הזו מסתיימת בהטמעה של אירועים מותאמים אישית במודעות מותאמות. הדוגמה המלאה מופיעה ב-GitHub.