Banner Ads - Ad Control Help Center

Overview

Banner ads are rectangular ads displayed in a portion of the screen. They can be used in both UIKit and SwiftUI.

Key Features

Can be fixed at the top, bottom, or middle of the screen
Supports both image and video ads
Supports both UIKit and SwiftUI
Ad event handling through delegates

Use test unit ID in development environment: PUBLIC_TEST_UNIT_ID_320_100

UIKit Implementation

In UIKit environment, implement banner ads using the AdropBanner class.

Basic Implementation

import UIKit
import AdropAds

class ViewController: UIViewController {
    private var banner: AdropBanner?

    override func viewDidLoad() {
        super.viewDidLoad()

        // 1. Create banner instance
        banner = AdropBanner(unitId: "YOUR_UNIT_ID")

        // 2. Set delegate
        banner?.delegate = self

        // 3. Add to view hierarchy
        if let bannerView = banner {
            view.addSubview(bannerView)

            // 4. Setup Auto Layout
            bannerView.translatesAutoresizingMaskIntoConstraints = false
            NSLayoutConstraint.activate([
                bannerView.centerXAnchor.constraint(equalTo: view.centerXAnchor),
                bannerView.bottomAnchor.constraint(equalTo: view.safeAreaLayoutGuide.bottomAnchor),
                bannerView.widthAnchor.constraint(equalToConstant: 320),
                bannerView.heightAnchor.constraint(equalToConstant: 100)
            ])
        }

        // 5. Load ad
        banner?.load()
    }

    deinit {
        // 6. Release banner resources before deallocation
        banner?.destroy()
        banner = nil
    }
}

// MARK: - AdropBannerDelegate
extension ViewController: AdropBannerDelegate {
    func onAdReceived(_ banner: AdropBanner) {
        print("Banner ad received successfully")
    }

    func onAdFailedToReceive(_ banner: AdropBanner, _ errorCode: AdropErrorCode) {
        print("Banner ad failed to receive: \(errorCode)")
    }

    func onAdImpression(_ banner: AdropBanner) {
        print("Banner ad impression")
    }

    func onAdClicked(_ banner: AdropBanner) {
        print("Banner ad clicked")
    }
}

AdropBanner Initialization

String

required

Unit ID created in Ad Control Console

let banner = AdropBanner(unitId: "YOUR_UNIT_ID")

Load Ad

Call the load() method to request an ad after adding the banner to the screen.

banner?.load()

Call load() when the banner is visible on screen. Loading when not visible may result in inaccurate impression measurements.

Set Context ID

You can set a Context ID for contextual targeting.

// contextId is read-only — set via initializer
let banner = AdropBanner(unitId: "YOUR_UNIT_ID", contextId: "sport")

SwiftUI Implementation

In SwiftUI environment, implement banner ads using AdropBannerRepresented.

Basic Implementation

import SwiftUI
import AdropAds

struct ContentView: View {
    @State private var represented = AdropBannerRepresented(unitId: "YOUR_UNIT_ID")

    var body: some View {
        VStack {
            Spacer()

            Text("Main Content")

            Spacer()

            // Banner ad
            represented
                .frame(width: 320, height: 100)
                .onAppear {
                    represented.banner.load()
                }
        }
    }
}

Delegate Handling

You can handle ad events through delegates.

import SwiftUI
import AdropAds

struct ContentView: View {
    @StateObject private var bannerDelegate = BannerDelegate()
    @State private var represented = AdropBannerRepresented(unitId: "YOUR_UNIT_ID")

    var body: some View {
        VStack {
            Spacer()

            if bannerDelegate.isLoaded {
                Text("Ad loaded successfully")
            }

            represented
                .frame(width: 320, height: 100)
                .onAppear {
                    represented.delegate = bannerDelegate
                    represented.banner.load()
                }
        }
    }
}

// Delegate implementation
class BannerDelegate: NSObject, ObservableObject, AdropBannerDelegate {
    @Published var isLoaded = false

    func onAdReceived(_ banner: AdropBanner) {
        print("Banner ad received successfully")
        isLoaded = true
    }

    func onAdFailedToReceive(_ banner: AdropBanner, _ errorCode: AdropErrorCode) {
        print("Banner ad failed to receive: \(errorCode)")
        isLoaded = false
    }

    func onAdImpression(_ banner: AdropBanner) {
        print("Banner ad impression")
    }

    func onAdClicked(_ banner: AdropBanner) {
        print("Banner ad clicked")
    }
}

Set Context ID

AdropBannerRepresented(
    unitId: "YOUR_UNIT_ID",
    contextId: "sport"
)
.frame(width: 320, height: 100)

Objective-C Implementation

How to implement banner ads in Objective-C environment.

Basic Implementation

@import AdropAds;

@interface ViewController () <AdropBannerDelegate>
@property (nonatomic, strong) AdropBanner *banner;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    // 1. Create banner instance
    self.banner = [[AdropBanner alloc] initWithUnitId:@"YOUR_UNIT_ID"];

    // 2. Set delegate
    self.banner.delegate = self;

    // 3. Add to view hierarchy
    [self.view addSubview:self.banner];

    // 4. Setup Auto Layout
    self.banner.translatesAutoresizingMaskIntoConstraints = NO;
    [NSLayoutConstraint activateConstraints:@[
        [self.banner.centerXAnchor constraintEqualToAnchor:self.view.centerXAnchor],
        [self.banner.bottomAnchor constraintEqualToAnchor:self.view.safeAreaLayoutGuide.bottomAnchor],
        [self.banner.widthAnchor constraintEqualToConstant:320],
        [self.banner.heightAnchor constraintEqualToConstant:100]
    ]];

    // 5. Load ad
    [self.banner load];
}

- (void)dealloc {
    [self.banner destroy];
    self.banner = nil;
}

#pragma mark - AdropBannerDelegate

- (void)onAdReceived:(AdropBanner *)banner {
    NSLog(@"Banner ad received successfully");
}

- (void)onAdFailedToReceive:(AdropBanner *)banner :(AdropErrorCode)errorCode {
    NSLog(@"Banner ad failed to receive: %ld", (long)errorCode);
}

- (void)onAdImpression:(AdropBanner *)banner {
    NSLog(@"Banner ad impression");
}

- (void)onAdClicked:(AdropBanner *)banner {
    NSLog(@"Banner ad clicked");
}

@end

Set Context ID

// contextId is read-only — set via initializer
AdropBanner *banner = [[AdropBanner alloc] initWithUnitId:@"YOUR_UNIT_ID" contextId:@"sport"];

Delegate Methods

The AdropBannerDelegate protocol handles ad lifecycle events.

onAdReceived (Required)

Called when ad is received successfully.

func onAdReceived(_ banner: AdropBanner) {
    print("Banner ad received successfully")
    // Handle ad loading indicator, etc.
}

onAdFailedToReceive (Required)

Called when ad fails to load.

func onAdFailedToReceive(_ banner: AdropBanner, _ errorCode: AdropErrorCode) {
    print("Banner ad failed to receive: \(errorCode)")
    // Handle errors and display alternative content
}

AdropErrorCode

Error code indicating the type of error. See Reference for details.

onAdImpression (Optional)

Called when ad is displayed on screen.

func onAdImpression(_ banner: AdropBanner) {
    print("Banner ad impression")
    // Handle impression analytics logging, etc.
}

onAdClicked (Optional)

Called when user clicks on the ad.

func onAdClicked(_ banner: AdropBanner) {
    print("Banner ad clicked")
    // Handle click analytics logging, etc.
}

onAdVideoStart (Optional)

Called when a video ad starts playing.

func onAdVideoStart(_ banner: AdropBanner) {
    print("Banner video started")
    // Handle video start analytics logging, etc.
}

onAdVideoEnd (Optional)

Called when a video ad finishes playing.

func onAdVideoEnd(_ banner: AdropBanner) {
    print("Banner video ended")
    // Handle video end analytics logging, etc.
}

Closure Callbacks

As an alternative to delegates, you can use closure-based callbacks.

let banner = AdropBanner(unitId: "YOUR_UNIT_ID")

banner.onAdReceived = { banner in
    print("Banner ad received")
}

banner.onAdFailedToReceive = { banner, errorCode in
    print("Banner ad failed: \(errorCode)")
}

banner.onAdImpression = { banner in
    print("Banner ad impression")
}

banner.onAdClicked = { banner in
    print("Banner ad clicked")
}

banner.onAdVideoStart = { banner in
    print("Banner video started")
}

banner.onAdVideoEnd = { banner in
    print("Banner video ended")
}

If both a delegate and closures are set, both will be called.

Lifecycle Management

destroy()

When you no longer need the banner, call destroy() to release its resources — WebView, tracking, and any active video playback are torn down actively. destroy() is idempotent, so calling it multiple times is safe. The instance cannot be reused after destroy.

deinit {
    banner?.destroy()
    banner = nil
}

- (void)dealloc {
    [self.banner destroy];
    self.banner = nil;
}

Skipping destroy() when the view controller deallocates leaves the WebView and related resources uncollected, which can cause memory leaks and performance degradation — especially impactful for video banners.

Ad Sizes

Banner ads require view size to match the size set in the unit.

Size	Use Case
320 x 50	Small banner
320 x 100	Large banner
16:9 ratio	Video banner

UIKit

bannerView.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
    bannerView.widthAnchor.constraint(equalToConstant: 320),
    bannerView.heightAnchor.constraint(equalToConstant: 100)
])

SwiftUI

represented
    .frame(width: 320, height: 100)
    .onAppear {
        represented.banner.load()
    }

Best Practices

1. Memory Management

Call destroy() when the view controller is deallocated to release banner resources.

deinit {
    banner?.destroy()
    banner = nil
}

2. Screen Visibility

Load ads when the banner is visible on screen.

override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)
    banner?.load()
}

Keep a single AdropBanner instance and call load() on it whenever you need a new ad. Do not create a new AdropBanner for every refresh. Recreating the banner for each ad request allocates a new WKWebView and its associated WebContent process each time. Under frequent refresh conditions — especially with video banners — this accumulates resource usage and can degrade rendering performance.

class ViewController: UIViewController {
    private var banner: AdropBanner?

    override func viewDidLoad() {
        super.viewDidLoad()
        banner = AdropBanner(unitId: "YOUR_UNIT_ID")
        banner?.delegate = self
        // Add to view hierarchy...
        banner?.load()
    }

    func refreshAd() {
        // Reuse the existing instance
        banner?.load()
    }
}

func refreshAd() {
    // Do NOT allocate a new AdropBanner on every refresh
    banner?.destroy()
    banner = AdropBanner(unitId: "YOUR_UNIT_ID")
    banner?.delegate = self
    // ...add to view hierarchy again
    banner?.load()
}

onAdReceived fires again on each subsequent load() call, so your existing delegate handles the new ad automatically.

4. Error Handling

Implement appropriate error handling when ad loading fails.

func onAdFailedToReceive(_ banner: AdropBanner, _ errorCode: AdropErrorCode) {
    switch errorCode {
    case .ERROR_CODE_NETWORK:
        print("Network error: Check connection")
    case .ERROR_CODE_AD_NO_FILL:
        print("No available ads")
    default:
        print("Ad load failed: \(errorCode)")
    }

    // Hide ad area or display fallback content
    bannerContainerView.isHidden = true

    // Or show your own promotional banner
    showPromotionBanner()
}

Test Unit IDs

Use the following test unit IDs during development and testing.

Ad Type	Test Unit ID	Size
Banner (320x50)	`PUBLIC_TEST_UNIT_ID_320_50`	320 x 50
Banner (320x100)	`PUBLIC_TEST_UNIT_ID_320_100`	320 x 100
Carousel Banner	`PUBLIC_TEST_UNIT_ID_CAROUSEL`	Variable
Banner Video (16:9)	`PUBLIC_TEST_UNIT_ID_BANNER_VIDEO_16_9`	16:9 ratio
Banner Video (9:16)	`PUBLIC_TEST_UNIT_ID_BANNER_VIDEO_9_16`	9:16 ratio

Usage Example

let banner = AdropBanner(unitId: AdropUnitId.PUBLIC_TEST_UNIT_ID_320_100)

AdropBanner *banner = [[AdropBanner alloc] initWithUnitId:PUBLIC_TEST_UNIT_ID_320_100];

Video Playback Control

For video banner ads, you can manually control video playback using play() and pause().

play()

Resumes video playback. Call this when the banner becomes visible again — for example, after a popup is dismissed or the app returns from the background.

banner?.play()

[self.banner play];

pause()

Pauses video playback. Call this when the banner is hidden by a popup or the app enters the background.

banner?.pause()

[self.banner pause];

Example: Background/Foreground Handling

override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
    banner?.play()
}

override func viewWillDisappear(_ animated: Bool) {
    super.viewWillDisappear(animated)
    banner?.pause()
}

play() and pause() only affect video banner ads. They have no effect on image banners.

Custom Click Handling

You can take control of ad click behavior by using useCustomClick. When enabled, the SDK will not automatically open the destination URL on click, and you can handle it yourself.

useCustomClick

let banner = AdropBanner(unitId: "YOUR_UNIT_ID")
banner.useCustomClick = true
banner.delegate = self
banner.load()

When useCustomClick is true, the SDK will not open the destination URL automatically when the ad is clicked. The onAdClicked delegate callback will still fire, and you can use the open() method or handle navigation yourself.

open()

Opens the destination URL of the ad. Can optionally pass a custom URL.

// Open the ad's default destination URL
banner?.open()

// Open a custom URL
banner?.open("https://example.com")

// Open using in-app browser
banner?.open(nil, useInAppBrowser: true)

Batch Loading (loads)

Use AdropBanner.loads(...) to request multiple banner ads in a single batched call. This is useful for building carousels, paginated feeds, or prefetching a pool of ads.

Signature

AdropBanner.loads(
    unitId: String,
    contextId: String = "",
    delegate: AdropBannerDelegate
)

[AdropBanner loadsWithUnitId:@"YOUR_UNIT_ID"
                   contextId:@""
                    delegate:delegate];

Usage

class ViewController: UIViewController {
    private var banners: [AdropBanner] = []

    override func viewDidLoad() {
        super.viewDidLoad()
        AdropBanner.loads(unitId: "YOUR_UNIT_ID", delegate: self)
    }
}

extension ViewController: AdropBannerDelegate {
    // Required single-load callbacks — unused on the batch path.
    func onAdReceived(_ banner: AdropBanner) { /* batch path */ }
    func onAdFailedToReceive(_ banner: AdropBanner, _ errorCode: AdropErrorCode) {}

    // Batch success — deliver up to 5 ready-to-use banners.
    func onAdsReceived(_ banners: [AdropBanner]) {
        self.banners = banners
        banners.forEach { banner in
            // Attach to your view hierarchy (UIScrollView, UIPageViewController, ...)
            stackView.addArrangedSubview(banner)
        }
    }

    // Batch failure
    func onAdsFailedToReceive(_ errorCode: AdropErrorCode) {
        print("Batch load failed: \(errorCode)")
    }

    // Click / impression / video callbacks still fire per instance.
    func onAdClicked(_ banner: AdropBanner) {
        print("Banner clicked")
    }

    func onAdImpression(_ banner: AdropBanner) {
        print("Banner impression")
    }
}

@interface ViewController () <AdropBannerDelegate>
@property (nonatomic, strong) NSArray<AdropBanner *> *banners;
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    [AdropBanner loadsWithUnitId:@"YOUR_UNIT_ID" contextId:@"" delegate:self];
}

#pragma mark - AdropBannerDelegate

- (void)onAdReceived:(AdropBanner *)banner { /* batch path */ }
- (void)onAdFailedToReceive:(AdropBanner *)banner :(AdropErrorCode)errorCode {}

- (void)onAdsReceived:(NSArray<AdropBanner *> *)banners {
    self.banners = banners;
    for (AdropBanner *banner in banners) {
        [self.stackView addArrangedSubview:banner];
    }
}

- (void)onAdsFailedToReceive:(AdropErrorCode)errorCode {
    NSLog(@"Batch load failed: %ld", (long)errorCode);
}

- (void)onAdClicked:(AdropBanner *)banner {
    NSLog(@"Banner clicked");
}

- (void)onAdImpression:(AdropBanner *)banner {
    NSLog(@"Banner impression");
}

@end

Delegate Methods

Method	When it fires
`onAdsReceived(_:)`	Batch delivered. Each `AdropBanner` already has the delegate attached and ad data applied.
`onAdsFailedToReceive(_:)`	Request rejected, network failure, or no fillable ads were returned (`ERROR_CODE_AD_NO_FILL`).
`onAdClicked` / `onAdImpression` / `onAdVideoStart` / `onAdVideoEnd`	Fire on each returned banner just like a single `load()`.

The singular onAdReceived(_:) / onAdFailedToReceive(_:_:) callbacks are not invoked on the loads path. Use onAdsReceived(_:) / onAdsFailedToReceive(_:) as the sole batch signals.

Constants

Int

default:"5"

Upper bound on ads returned from a single loads(...) call.

Constraints

Maximum 5 ads per call. If the server returns more, only the first 5 are delivered.
Backfill is not applied. If no direct ads fill, onAdsFailedToReceive is called with ERROR_CODE_AD_NO_FILL regardless of backfill configuration.
Do not call destroy() inside onAdsReceived. Attach each banner to the view hierarchy first, then call destroy() when the view controller deallocates.
onAdsReceived fires as soon as ad data is applied, matching the single load() contract — the creative paints shortly after you add the banner to a view hierarchy.
Hold strong references to the returned banners (e.g., store them on the view controller). If they deallocate before being attached, they’re silently dropped.

Backfill Ads

When backfill ads are enabled, backfill ads are automatically loaded when direct ads are unavailable. Use the isBackfilled property to check if the ad is a backfill ad.

class ViewController: UIViewController, AdropBannerDelegate {
    private var banner: AdropBanner?

    func onAdReceived(_ banner: AdropBanner) {
        if banner.isBackfilled {
            print("Backfill ad loaded")
        } else {
            print("Direct ad loaded")
        }
    }

    func onAdFailedToReceive(_ banner: AdropBanner, _ errorCode: AdropErrorCode) {
        switch errorCode {
        case .ERROR_CODE_AD_NO_FILL:
            print("No direct ad, requesting backfill...")
        case .ERROR_CODE_AD_BACKFILL_NO_FILL:
            print("No backfill ad available")
            // Hide ad area
            banner.isHidden = true
        default:
            print("Ad load failed: \(errorCode)")
        }
    }
}

@interface ViewController () <AdropBannerDelegate>
@property (nonatomic, strong) AdropBanner *banner;
@end

@implementation ViewController

- (void)onAdReceived:(AdropBanner *)banner {
    if (banner.isBackfilled) {
        NSLog(@"Backfill ad loaded");
    } else {
        NSLog(@"Direct ad loaded");
    }
}

- (void)onAdFailedToReceive:(AdropBanner *)banner :(AdropErrorCode)errorCode {
    if (errorCode == AdropErrorCodeAdNoFill) {
        NSLog(@"No direct ad, requesting backfill...");
    } else if (errorCode == AdropErrorCodeBackfillNoFill) {
        NSLog(@"No backfill ad available");
        // Hide ad area
        banner.hidden = YES;
    } else {
        NSLog(@"Ad load failed: %ld", (long)errorCode);
    }
}

@end

To use backfill ads, add the AdropAds-Backfill dependency. See Getting Started.

Preloading Backfill Ads (preload)

Starting with SDK 1.17.0, you can use AdropBanner.preload() to preload a backfill banner ad. When a banner that you load() with the same unit ID and the same size gets no direct ad and falls back to a backfill ad, it displays the preloaded ad right away instead of requesting a backfill ad again. load() still requests a direct ad first, regardless of preload. If a direct ad is displayed, the preloaded ad is kept as is. If you don’t call preload, the behavior is the same as before.

Requirements

Both adrop-ads and adrop-ads-backfill must be 1.17.0 or later.
Preload fetches a backfill ad only when the server has told the app that there are no direct ads to show right now. Otherwise, it ends with ERROR_CODE_AD_PRELOAD_SKIPPED without requesting a backfill ad. This is a normal result in apps that have direct ad campaigns.
Right after the app is installed, right after you change the App Key, and right after you switch to a different user with setUID, preload ends with ERROR_CODE_AD_PRELOAD_SKIPPED until the server response arrives.
With test unit IDs, preload always ends with ERROR_CODE_AD_PRELOAD_SKIPPED.

Usage

Call preload right before you open the screen that contains the banner. A preloaded ad is discarded after 30 minutes if it isn’t used, so call preload only for banners you’re about to display. You don’t need to wait for the result before calling load(). If the ad is still being fetched, load() waits for that result and uses it. delegate is held weakly. To receive the result callback, keep the delegate object alive until the result arrives.

import UIKit
import AdropAds

final class HomeViewController: UIViewController, AdropBannerDelegate {
    // Call right before you open the screen that contains the banner.
    func preloadFeedBanner() {
        AdropBanner.preload(
            unitId: "YOUR_UNIT_ID",
            adSize: CGSize(width: 320, height: 50), // 320x50 if omitted
            delegate: self
        )
    }

    func onAdPreloadReceived(_ unitId: String, _ contextId: String) {
        print("Preload complete: \(unitId)")
    }

    func onAdPreloadFailedToReceive(_ unitId: String, _ contextId: String, _ errorCode: AdropErrorCode) {
        // ERROR_CODE_AD_PRELOAD_SKIPPED is a normal result.
        // Don't call preload again right away here.
        print("Not preloaded: \(errorCode.rawValue)")
    }

    // Not called for preload.
    func onAdReceived(_ banner: AdropBanner) {}
    func onAdFailedToReceive(_ banner: AdropBanner, _ errorCode: AdropErrorCode) {}
}

@import AdropAds;

@interface HomeViewController () <AdropBannerDelegate>
@end

@implementation HomeViewController

// Call right before you open the screen that contains the banner.
- (void)preloadFeedBanner {
    [AdropBanner preloadWithUnitId:@"YOUR_UNIT_ID"
                         contextId:@""
                            adSize:CGSizeMake(320, 50)
                          delegate:self];
}

- (void)onAdPreloadReceived:(NSString *)unitId :(NSString *)contextId {
    NSLog(@"Preload complete: %@", unitId);
}

- (void)onAdPreloadFailedToReceive:(NSString *)unitId :(NSString *)contextId :(AdropErrorCode)errorCode {
    // AdropErrorCodeERROR_CODE_AD_PRELOAD_SKIPPED is a normal result.
    // Don't call preload again right away here.
    NSLog(@"Not preloaded: %ld", (long)errorCode);
}

// Not called for preload.
- (void)onAdReceived:(AdropBanner *)banner {}
- (void)onAdFailedToReceive:(AdropBanner *)banner :(AdropErrorCode)errorCode {}

@end

To use the preloaded ad, make the banner’s frame size match the adSize you passed to preload before you call load().

let banner = AdropBanner(unitId: "YOUR_UNIT_ID")
banner.frame = CGRect(x: 0, y: 0, width: 320, height: 50) // Size passed to preload
banner.delegate = self
view.addSubview(banner)
banner.load()

AdropBanner *banner = [[AdropBanner alloc] initWithUnitId:@"YOUR_UNIT_ID" contextId:@""];
banner.frame = CGRectMake(0, 0, 320, 50); // Size passed to preload
banner.delegate = self;
[self.view addSubview:banner];
[banner load];

When a Preloaded Ad Is Used

Same unit ID and same size: When you call load(), the banner’s frame size must match the adSize you passed to preload. If you size the banner only with Auto Layout, its size may not be determined yet when you call load(). If the size differs, the preloaded ad is kept as is, and load() requests a backfill ad as usual.
Not tied to a screen: preload doesn’t take a view controller. An ad preloaded on a different screen is also used by the banner you load().
Used only once: A preloaded ad is gone once a single load() uses it. To preload again, call preload again.
Lifetime and count: An ad that isn’t used within 30 minutes is discarded. Only 1 ad is kept per unit and size, and banners keep up to 5 different unit/size combinations. When there are more than 5, ads are discarded starting with the one received first.
Calling again: Calling preload again with the same unit and size doesn’t make a new request. If an ad has already been preloaded, onAdPreloadReceived is called without a new request; if one is still being fetched, you get that load’s result (success or failure). You can’t use preload to refresh an ad. However, if the user consent status has changed in the meantime, the existing ad is discarded and a new one is fetched.
Consent status changes: If the user consent status changes after an ad is preloaded, that ad isn’t used by load().

Result Delegate Methods

The following optional methods have been added to AdropBannerDelegate. Each time you call preload, one of the two is called once on the main thread. No other delegate methods are called for preload.

Method	When it fires
`onAdPreloadReceived(_:_:)`	When preloading has finished. A `load()` that was waiting for that result may have already used the ad.
`onAdPreloadFailedToReceive(_:_:_:)`	When the ad couldn’t be preloaded

The second argument, contextId, returns the value you passed to preload as is (default: empty string). It isn’t used to select a preloaded ad.

Failure Codes

Error Code	Description
`ERROR_CODE_AD_PRELOAD_SKIPPED`	No backfill ad was requested because direct ads may be shown, or because that hasn’t been confirmed yet. This is a normal result, so call preload again right before you open the next screen.
`ERROR_CODE_AD_NO_FILL`	The backfill dependency (1.17.0 or later) is missing, the device isn’t in the target countries of `Adrop.initialize()`, backfill isn’t configured for the unit, or the SDK hasn’t received that configuration yet. Call preload again a little later. If the backfill dependency is missing or the device isn’t in the target countries, preload keeps ending with this code.
`ERROR_CODE_AD_BACKFILL_NO_FILL`	No backfill ad is available.
`ERROR_CODE_INITIALIZE`	The SDK isn’t initialized.
`ERROR_CODE_INVALID_UNIT`	The unit ID is empty.

Don’t call preload again right away inside the failure callback. If the result doesn’t change — for example, when the backfill dependency is missing — the calls repeat endlessly. Call it again later, such as before you open the next screen.

Next Steps

Native Ads

Implementing customizable native ads

Interstitial Ads

Implementing full-screen interstitial ads

Targeting Settings

Setting up user attributes and contextual targeting

Reference

Classes, delegates, error codes reference

​Overview

​Key Features

​UIKit Implementation

​Basic Implementation

​AdropBanner Initialization

​Load Ad

​Set Context ID

​SwiftUI Implementation

​Basic Implementation

​Delegate Handling

​Set Context ID

​Objective-C Implementation

​Basic Implementation

​Set Context ID

​Delegate Methods

​onAdReceived (Required)

​onAdFailedToReceive (Required)

​onAdImpression (Optional)

​onAdClicked (Optional)

​onAdVideoStart (Optional)

​onAdVideoEnd (Optional)

​Closure Callbacks

​Lifecycle Management

​destroy()

​Ad Sizes

​Common Banner Sizes

​UIKit

​SwiftUI

​Best Practices

​1. Memory Management

​2. Screen Visibility

​3. Reuse the Banner Instance

​4. Error Handling

​Test Unit IDs

​Usage Example

​Video Playback Control

​play()

​pause()

​Example: Background/Foreground Handling

​Custom Click Handling

​useCustomClick

​open()

​Batch Loading (loads)

​Signature

​Usage

​Delegate Methods

​Constants

​Constraints

​Backfill Ads

​Preloading Backfill Ads (preload)

​Requirements

​Usage

​When a Preloaded Ad Is Used

​Result Delegate Methods

​Failure Codes

​Next Steps

Native Ads

Interstitial Ads

Targeting Settings

Reference

Overview

Key Features

UIKit Implementation

Basic Implementation

AdropBanner Initialization

Load Ad

Set Context ID

SwiftUI Implementation

Basic Implementation

Delegate Handling

Set Context ID

Objective-C Implementation

Basic Implementation

Set Context ID

Delegate Methods

onAdReceived (Required)

onAdFailedToReceive (Required)

onAdImpression (Optional)

onAdClicked (Optional)

onAdVideoStart (Optional)

onAdVideoEnd (Optional)

Closure Callbacks

Lifecycle Management

destroy()

Ad Sizes

Common Banner Sizes

UIKit

SwiftUI

Best Practices

1. Memory Management

2. Screen Visibility

3. Reuse the Banner Instance

4. Error Handling

Test Unit IDs

Usage Example

Video Playback Control

play()

pause()

Example: Background/Foreground Handling

Custom Click Handling

useCustomClick

open()

Batch Loading (loads)

Signature

Usage

Delegate Methods

Constants

Constraints

Backfill Ads

Preloading Backfill Ads (preload)

Requirements

Usage

When a Preloaded Ad Is Used

Result Delegate Methods

Failure Codes

Next Steps