Interstitial Ads

Ad Request

Placement

Create placement from AdFormat with your parameters:

Swift
Objective-C

let placement = try? BidMachineSdk.shared.placement(.intersitial) {
  $0.withPlacementId("")
  $0.withCustomParameters([String:Any]())
}

NSError *error = nil;

BidMachinePlacement *placement = [BidMachineSdk.shared placement:BidMachineAdFormat.interstitial
                                                           error:&error
                                                         builder:^(id<BidMachinePlacementBuilderProtocol> _Nonnull builder) {
  [builder withPlacementId:@""];
  [builder withCustomParameters:@{}];
}];

Parameter	Type	Description
`placementId`	`String`	Placement ID
`customParameters`	`[String: Any]` / `NSDictionary`	Passed directly to the server

AdFormat

The placement format is defined by static properties of the AdFormat class:

Swift
Objective-C

@objc(BidMachineAdFormat)
final public class AdFormat : NSObject {
    @objc public static var interstitial: BidMachine.AdFormat { get }
    @objc public static var interstitialStatic: BidMachine.AdFormat { get }
    @objc public static var interstitialVideo: BidMachine.AdFormat { get }
}

@interface BidMachineAdFormat (SWIFT_EXTENSION(BidMachine))
  + (BidMachineAdFormat * _Nonnull)interstitial;
  + (BidMachineAdFormat * _Nonnull)interstitialStatic;
  + (BidMachineAdFormat * _Nonnull)interstitialVideo;
@end

Available interstitial formats

Format	Description
`interstitial`	Combines both VAST (video) and MRAID (static) formats
`interstitialVideo`	VAST video ads only
`interstitialStatic`	MRAID static ads only

General Request

Auction request is used to set bidding parameters: The request is created with a special placement and your parameters

Swift
Objective-C

let request = BidMachineSdk.shared.auctionRequest(placement: placement) {
  $0.withUnitConfigurations([BidMachineUnitConfiguration]())
  $0.appendPriceFloor(Double(10), UUID().uuidString)
}

BidMachineAuctionRequest *request = [[BidMachineSdk shared] auctionRequestWithPlacement:placement builder: ^(id<BidMachineAuctionRequestBuilderProtocol> _Nonnull builder) {
    [builder withUnitConfigurations:@[]];
    [builder appendPriceFloor:10.0 identifier:[[NSUUID UUID] UUIDString]];
}];

Parameter	Type	Description
`unitConfigurations`	`[BidMachineUnitConfiguration]`	Header bidding unit configurations
`priceFloor`	`(Double, String)`	Price floor (value and identifier)

Client Bidding Request

Bid Token

With S2S integration, you will need a token that you need to transfer in the request. To get a token, you can use method:

Swift
Objective-C

BidMachineSdk.shared.token(placement: placement) { token in }

[BidMachineSdk.shared tokenWithPlacement:placement completion:^(NSString *token) {

}];

Bid Payload

After completing the server-side auction, you will receive a Base64-encoded payload string, which must be passed as a parameter to the AuctionRequest.

Swift
Objective-C

let request = BidMachineSdk.shared.auctionRequest(placement: placement) {
  $0.withPayload("")
}

BidMachineAuctionRequest *request = [[BidMachineSdk shared] auctionRequestWithPlacement:placement builder: ^(id<BidMachineAuctionRequestBuilderProtocol> _Nonnull builder) {
  [builder withPayload:@""];
}];

Parameter	Type	Description
`payload`	`String`	Custom BidMachine payload string

Ad Display

The ad object is used to download and display ads.

Prepare the ad object

Request an ad using your auction request:

Swift
Objective-C

BidMachineSdk.shared.interstitial(request: request) { [weak self] ad, error in
  guard let self else { return }
  self.interstitial = ad
}

__weak typeof(self) weakSelf = self;
[[BidMachineSdk shared] interstitialWithRequest:request
                             completion:^(BidMachineInterstitial *ad, NSError * _Nullable error) {
  __strong typeof(weakSelf) strongSelf = weakSelf;
  if (!strongSelf) {
      return;
  }
  strongSelf.interstitial = ad;
}];

The prepared ad contains auctionInfo and requestInfo.

Auction Info

The auctionInfo contains information about the auction, such as the winning bidder, price, and other relevant details. The auctionInfo is described here.

Delegate

Subscribe to ad events:

Swift
Objective-C

ad.delegate = self

ad.delegate = self;

Implement BidMachineAdDelegate methods:

Swift
Objective-C

func didLoadAd(_ ad: BidMachineAdProtocol) {}
func didFailLoadAd(_ ad: BidMachineAdProtocol, _ error: Error) {}
func didPresentAd(_ ad: BidMachineAdProtocol) {}
func didFailPresentAd(_ ad: BidMachineAdProtocol, _ error: Error) {}
func didDismissAd(_ ad: BidMachineAdProtocol) {}
func willPresentScreen(_ ad: BidMachineAdProtocol) {}
func didDismissScreen(_ ad: BidMachineAdProtocol) {}
func didUserInteraction(_ ad: BidMachineAdProtocol) {}
func didExpired(_ ad: BidMachineAdProtocol) {}
func didTrackImpression(_ ad: BidMachineAdProtocol) {}
func didTrackInteraction(_ ad: BidMachineAdProtocol) {}
func didReceiveReward(_ ad: BidMachineAdProtocol) {}

- (void)didLoadAd:(id<BidMachineAdProtocol>)ad {}
- (void)didFailLoadAd:(id<BidMachineAdProtocol>)ad :(NSError *)error {}
- (void)didPresentAd:(id<BidMachineAdProtocol>)ad {}
- (void)didFailPresentAd:(id<BidMachineAdProtocol>)ad :(NSError *)error {}
- (void)didDismissAd:(id<BidMachineAdProtocol>)ad {}
- (void)willPresentScreen:(id<BidMachineAdProtocol>)ad {}
- (void)didDismissScreen:(id<BidMachineAdProtocol>)ad {}
- (void)didUserInteraction:(id<BidMachineAdProtocol>)ad {}
- (void)didExpired:(id<BidMachineAdProtocol>)ad {}
- (void)didTrackImpression:(id<BidMachineAdProtocol>)ad {}
- (void)didTrackInteraction:(id<BidMachineAdProtocol>)ad {}
- (void)didReceiveReward:(id<BidMachineAdProtocol>)ad {}

Loading and presenting interstitial ads

Loading prerequisites

Make sure both the delegate and controller are set before loading.

Example of intestitial ad loading:

Swift
Objective-C

guard let placement = try? BidMachineSdk.shared.placement(.interstitial) else { return }
let request = BidMachineSdk.shared.auctionRequest(placement: placement)
BidMachineSdk.shared.interstitial(request: request) { [weak self] ad, error in
  guard let self = self else {
      return
  }
  self.interstitial = ad
  self.interstitial.controller = self
  self.interstitial.delegate = self
  self.interstitial.loadAd()
}

NSError *error = nil;
BidMachinePlacement *placement = [BidMachineSdk.shared placement:BidMachineAdFormat.interstitial
                                                           error:&error
                                                         builder:nil];
if (!placement) {
    return;
}

BidMachineAuctionRequest *request = [[BidMachineSdk shared] auctionRequestWithPlacement:placement
                                                                                builder:nil];

__weak typeof(self) weakSelf = self;
[[BidMachineSdk shared] interstitialWithRequest:request
                                    completion:^(BidMachineInterstitial *ad, NSError * _Nullable error) {
    __strong typeof(weakSelf) strongSelf = weakSelf;
    if (!strongSelf) {
        return;
    }
    strongSelf.interstitial = ad;
    strongSelf.interstitial.controller = strongSelf;
    strongSelf.interstitial.delegate = strongSelf;
    [strongSelf.interstitial loadAd];
}];

Present the loaded ad:

Swift
Objective-C

interstitial.presentAd()

[self.interstitial presentAd];

Ad Request​

Placement​

AdFormat​

Available interstitial formats​

General Request​

Client Bidding Request​

Bid Token​

Bid Payload​

Ad Display​

Prepare the ad object​

Delegate​

Loading and presenting interstitial ads​