Banner Cache
Integrate Banner Cache
The banner cache is a special tool to help you integrate infeed banners more easily. It will wrap an infeed banner and use it to automatically preload banner ads aiming to have a defined amount of banners available for an immediate handout to the app whenever they are needed. Compared to using the infeed banner directly, it comes with the following
Pros
Automatically caches banner ads, so your app can consume and present them whenever needed (i.e. when the dedicated feed cell enters the visible area of the screen)
Automatically takes care of correct ad space counting (it counts an ad space whenever you try to consume an ad because we assume, you only consume an ad when you need to present it right now).
Allows server-side configuration of frequency capping: You can configure frequency capping for banner cache placements within the Dashboard at page "Settings / Placements" (e.g. show not more than 1 impression per hour), so you don’t need to implement frequency capping yourself.
Cons
You cannot specify specific configurations for the ad request (like e.g. keyword targeting X for the first ad request and keyword targeting Y for the next one and so on) and control the load cycle of a specific ad.
Create Banner Cache
let configuration = AATBannerCacheConfiguration(placementName: "<PLACEMENT_NAME>", size: 3)
configuration.delegate = self
bannerCache = AATSDK.createBannerCache(configuration: configuration)
Banner Cache Configuration
AATBannerCacheConfiguration can be configured with the following:
placementName
defines the name of the internally wrapped placement (e.g. important for the statistics on the Dashboard).size
defines how many preloaded banners should be available in the cache. Max value: 5.
delegate
an instance of AATBannerCacheDelegate that will notify you when the first banner is loaded and ready to be consumed.requestConfiguration
an instance of AATBannerRequest that will be used internally for requesting banner ads from theAATInfeedBannerPlacement
.minDelay
represents the minimum delay between two banner consumptions in seconds. Useful to prevent consuming too many ads when the user is fast scrolling. Default: 1 s.shouldCacheAdditionalAdAtStart
defines if the cache should load an additional ad at the beginning.false
by default.
Configure Banner Request
See the banner request configuration for infeed banner placement.
let request = AATBannerRequest(delegate: self)
request.targetingInformation = ["key": ["value"]]
request.contentTargetingUrl = "http://example.com/similar/content"
OR
request.multiContentTargetingUrls = ["URL1", "URL2"]
request.setRequestBannerSizes(sizes: Set(arrayLiteral: .banner320x53, .banner300x250))
Consume Banners
To consume banners, use this API: func consume(force: Bool = false) -> AATBannerPlacementWrapperView?
. It returns an instance of UIView to be used within the app. Can return nil if there are no banners available in the cache. Also automatically counts an ad space. BannerCache will no longer hold any references to returned banners, and they need to be destroyed manually by the app.
If the force
parameter is true, the minDelay
parameter of the AATBannerCacheConfiguration instance will be ignored.
let bannerView = bannerCache.consume()
Cache Status Delegate
To listen to the banner cache status, conform to the AATBannerCacheStatusDelegate
and set the banner cache cacheStatusDelegate
property.
bannerCache?.cacheStatusDelegate = self
Complete Code Example
class ViewController: UIViewController {
private var bannerCache: AATBannerCache?
override func viewDidAppear(_ animated: Bool) {
super.viewDidAppear(animated)
// [IMPORTANT] Notify AATKit about the currently active view controller
AATSDK.controllerViewDidAppear(controller: self)
// Create banner cache configuration instance
let configuration = AATBannerCacheConfiguration(placementName: "<PLACEMENT_NAME>", size: 1)
configuration.delegate = self
// Create the banner request instance
let request = AATBannerRequest(delegate: self)
// Configure request banner sizes
request.setRequestBannerSizes(sizes: Set([.banner320x53, .banner300x250]))
// Configure request targeting information
request.contentTargetingUrl = "http://example.com/similar/content"
// OR
request.multiContentTargetingUrls = ["URL1", "URL2"]
// Configure request content targeting URL
request.targetingInformation = ["key": ["value"]]
// Set configuration banner request
configuration.requestConfiguration = request
// Create the banner cache (once it has been created, it would start loading automatically)
bannerCache = AATSDK.createBannerCache(configuration: configuration)
// Setting banner cache status delegate
bannerCache?.cacheStatusDelegate = self
}
override func viewWillDisappear(_ animated: Bool) {
super.viewWillDisappear(animated)
// Destroy the banner cache when it's not needed anymore
bannerCache?.destroy()
// [IMPORTANT] Remove the currently active view controller
AATSDK.controllerViewWillDisappear()
}
}
extension ViewController: AATBannerCacheDelegate {
func firstBannerLoaded() {
// Get the banner view
guard let bannerView = bannerCache?.consume() else {
print("An error occurred")
return
}
// Change bannerView frame (or constraints) to the desired location on the screen
}
}
extension ViewController: AATBannerCacheStatusDelegate {
func cacheIsNoLongerEmpty() {
//Cache is no longer empty
}
func cacheIsEmpty() {
// Cache is empty
}
}
Last updated