Floxis SDK API reference#

This page lists every public class, method, property and constant in the Floxis SDK for Android and iOS, grouped by artifact. Use it to look up a signature, a default or a threading rule. For setup steps, see the platform guides listed at the end of the page.

The SDK ships as binaries. Only the API on this page is supported. Anything in an internal package, and any class you see in a stack trace that is not listed here, can change without notice.

Artifacts and availability#

Availability note. Artifacts marked "Next release" or "Not yet published" are available from the next release. Contact your Floxis account manager for early access. Until then, their coordinates do not resolve from maven.floxis.tech.

Members marked Next release below are not in 0.2.0. Everything else on the Android AdMob and Next-Gen artifacts is in 0.2.0. In 0.2.0 the shared types (Floxis, FloxisConfig, AuctionOutcome and the rest) shipped inside floxis-sdk and floxis-sdk-nextgen. From the next release they live in floxis-sdk-common, in the same com.floxis.sdk package, so your imports and code do not change.

Each Android release on maven.floxis.tech also has a Javadoc jar next to the AAR. There is no sources jar.

Conventions#

Language and Java callers#

Android signatures are written in Kotlin. Every class works from Java:

• A parameter with a default value is optional in Kotlin. Java gets one overload per optional parameter, dropping them from the end. To set a later optional parameter from Java, pass every one before it.
• Floxis methods and the load methods on full-screen classes are static in Java: Floxis.initialize(...), FloxisInterstitialAd.load(...).
• Constants are static fields in Java: FloxisConfig.DEFAULT_TIMEOUT_MS, FloxisShowError.EXPIRED.
• Interfaces marked fun interface take a Kotlin lambda or a Java lambda.

Errors#

• Bad arguments throw. Constructors and helpers that validate input throw IllegalArgumentException. This covers FloxisConfig, FloxisSize, FloxisVideoOptions, every banner and GAM constructor, the MAX wrappers and FloxisPriceTiers. On iOS, FloxisConfiguration.init throws FloxisConfigurationError.
• Auctions never throw. After construction, a failure inside a Floxis auction ends as AuctionStatus.ERROR (or TIMEOUT), a warning is logged, and your ad server or mediation SDK still loads without Floxis.

Threads#

Placement IDs (configId / configID)#

configId is your name for the placement, for example home_banner. Floxis reports by placement, so give each placement its own name and keep it the same across app versions. It is trimmed and sent as the impression's placement ID. It must not be blank. On iOS it must be 1 to 128 characters.

R8 and ProGuard#

Each AAR ships its own consumer rules. You do not add any keep rules for Floxis. Release AARs are minified: public names are kept and everything else is renamed. Line numbers are kept, so your crash reports still show where a Floxis frame was.

Not part of the API#

• Classes named BuildConfig in any Floxis package. Use Floxis.SDK_VERSION (Android) or Floxis.sdkVersion (iOS).
• Anything under com.floxis.sdk.internal, com.floxis.sdk.nextgen.internal or com.floxis.sdk.levelplay.

Android: shared runtime#

Package com.floxis.sdk. These types come with floxis-sdk, floxis-sdk-nextgen, floxis-sdk-gam and floxis-sdk-max. An app that combines several of these artifacts has one runtime: one Floxis.initialize call, with one seat and region, configures all of them. floxis-sdk-levelplay does not use these types.

Floxis#

public object Floxis. The SDK entry point.

initialize

• Call it once at start-up, after your consent tool has run. For AdMob and GAM, call it from the MobileAds.initialize callback.
• It is safe to call more than once and from any thread. A later call replaces the config used by later auctions.
• listener is always called, on the main thread, with the result.
• With config.enabled = false it reports DISABLED and starts nothing.
• If start-up fails, the next ad load retries it, at most once every 30 seconds. Until it succeeds, auctions are SKIPPED_NOT_INITIALIZED and your ads still load without Floxis.
• Start-up gives up and reports FAILED after 12 seconds without an answer.

MobileAds.initialize(this) {
    Floxis.initialize(
        applicationContext,
        FloxisConfig(seat = "YOUR_SEAT", region = "us-e"),
    ) { status, description -> Log.d("Floxis", "init $status $description") }
}

MobileAds.initialize(this, initializationStatus ->
    Floxis.initialize(getApplicationContext(), new FloxisConfig("YOUR_SEAT", "us-e"),
        (status, description) -> Log.d("Floxis", "init " + status + " " + description)));

FloxisInitListener and FloxisInitStatus#

public fun interface FloxisInitListener {
    public fun onInitialized(status: FloxisInitStatus, description: String?)
}

FloxisConfig#

public class FloxisConfig. Settings passed to Floxis.initialize. Every field is read-only after construction.

The constructor throws IllegalArgumentException for a bad seat, region or timeout, or a blank storeUrl.

val config = FloxisConfig(
    seat = "YOUR_SEAT",
    region = "us-e",
    timeoutMs = 1500,
    debug = BuildConfig.DEBUG,
    testMode = BuildConfig.DEBUG,
)

From Java there is no builder: pass the parameters in order, for example new FloxisConfig("YOUR_SEAT", "us-e", 1500, true, true, true, true) for seat, region, timeout, debug, enabled, personalizedAds and testMode.

FloxisSize#

public data class FloxisSize(val width: Int, val height: Int). An ad size in dp. Both values must be positive, or the constructor throws.

AuctionOutcome, AuctionStatus and FloxisAuctionListener#

AuctionOutcome describes one Floxis auction. You receive it; you never create it.

In every case your ad server or mediation SDK still loads. An auction BID does not prove an impression: the ad server still chooses the winner.

public fun interface FloxisAuctionListener {
    public fun onAuctionComplete(outcome: AuctionOutcome)
}

Called on the main thread after each auction, once the ad server request has been sent.

FloxisLoadHandle#

public fun interface FloxisLoadHandle {
    public fun cancel()
}

Returned by full-screen load calls. cancel() drops the pending load: no callback fires afterwards. On Next-Gen, an ad that loads after cancel() is destroyed for you.

FloxisShowResult and FloxisShowError#

show on the AdMob and Next-Gen full-screen classes returns a FloxisShowResult.

EXPIRED and DISABLED apply only when Floxis won the slot. An ad from another source shows as usual.

A refused show also reaches your show-failure callback, so code that reloads from there keeps working. The error's domain is FloxisShowError.DOMAIN ("com.floxis.sdk"), its code is the value above, and its message is Floxis refused to show the ad: <RESULT>. On classic AdMob it is the AdError passed to onAdFailedToShowFullScreenContent. On Next-Gen it is a FullScreenContentError with code INTERNAL_ERROR whose cause is a MediationAdError with that domain and code.

FloxisShowError.codeFor(result: FloxisShowResult): Int maps a result to its code.

FloxisInterstitialFormat, FloxisInterstitialOptions and FloxisVideoOptions#

public class FloxisInterstitialOptions(
    public val format: FloxisInterstitialFormat = FloxisInterstitialFormat.DISPLAY_AND_VIDEO,
    minWidthPercent: Int? = null,
    minHeightPercent: Int? = null,
    public val video: FloxisVideoOptions = FloxisVideoOptions(),
)

• minWidthPercent and minHeightPercent set the smallest display creative as a share of the screen. They are clamped to 0..100 and sent only when both are set. Read them back with the properties of the same names.
• video applies when format includes video.

public class FloxisVideoOptions(
    public val minDurationSeconds: Int? = null,
    public val maxDurationSeconds: Int? = null,
    public val skippable: Boolean? = null,
)

• Leave a field null to let buyers choose, which keeps the most video demand.
• Durations must be positive, and minDurationSeconds must not exceed maxDurationSeconds, or the constructor throws.
• skippable = true asks for skippable creatives only; false asks for non-skippable only.

val options = FloxisInterstitialOptions(
    format = FloxisInterstitialFormat.VIDEO,
    video = FloxisVideoOptions(maxDurationSeconds = 30),
)

FloxisPriceTiers#

public object FloxisPriceTiers. Helpers for the price tiers in your AdMob setup sheet. You only need them if you build Custom Events or reports yourself.

• With tiers null or empty, bucketFor uses the default ladder: the price is truncated to a 0.10 step and capped at 20.00, so 1.27 gives "1.20" and 35.0 gives "20.00".
• With your endpoint's own tiers, bucketFor returns the highest tier at or below the price: bucketFor(1.25, listOf("1.00", "1.25", "25.00")) is "1.25".
• Below the lowest tier, bucketFor returns "0.00", which is not a Custom Event.
• customEventParameter throws if bucket is not exactly one of the tiers.
• A tier list must have at most 500 tiers, each 0.01 to 999.99 with up to two decimals, in strictly ascending order. Otherwise both methods throw. Tiers are written with two decimals, so "1.5" becomes "1.50".

Android: AdMob (floxis-sdk)#

Package com.floxis.sdk. Built on com.google.android.gms:play-services-ads 25.5.0, Prebid Mobile 3.4.0 and Prebid's AdMob adapters 3.4.0, which Gradle adds for you. Minimum Android SDK 24; your app compiles against API 35. Cannot share an app with floxis-sdk-nextgen.

FloxisRequestFactory#

public fun interface FloxisRequestFactory {
    public fun newBuilder(): AdRequest.Builder
    // companion: @JvmField val DEFAULT: FloxisRequestFactory
}

Returns a fresh AdRequest.Builder for every AdMob load, so you can add your own targeting. DEFAULT returns AdRequest.Builder(). Floxis adds its adapter extras to the builder you return. When personalised ads are off it also adds an AdMobAdapter extras bundle holding only npa=1, which replaces any AdMobAdapter extras bundle you added.

banner.load { AdRequest.Builder().setContentUrl("https://example.com/article") }

FloxisLoadCallback#

public interface FloxisLoadCallback<T> {
    public fun onAdLoaded(ad: T)
    public fun onAdFailedToLoad(error: LoadAdError, auction: AuctionOutcome)
}

Called on the main thread. onAdFailedToLoad fires when AdMob fails to load, including an ordinary AdMob no-fill. auction says what Floxis did for that load.

FloxisBannerAd#

Runs a fresh Floxis auction before every AdMob banner load and owns refresh. Turn off automatic refresh on the AdMob ad unit.

public class FloxisBannerAd(
    adView: AdView,
    configId: String,
    sizes: List<FloxisSize>,
    refreshIntervalSeconds: Int = DEFAULT_REFRESH_SECONDS,
    listener: FloxisAuctionListener? = null,
)

Refresh runs only while the app is in the foreground, the screen is on, and at least half of the banner is visible. Otherwise it waits for the next interval. It pauses while the view is detached from the window, and the banner destroys itself when the activity or fragment that holds it is destroyed.

val banner = FloxisBannerAd(adView, "home_banner", listOf(FloxisSize(320, 50)))
banner.load()

override fun onPause() { banner.pause(); adView.pause(); super.onPause() }
override fun onResume() { super.onResume(); adView.resume(); banner.resume() }
override fun onDestroy() { banner.destroy(); adView.destroy(); super.onDestroy() }

FloxisInterstitialAd#

load parameters, in order:

var interstitial: FloxisInterstitialAd? = null
FloxisInterstitialAd.load(
    context = this,
    adMobAdUnitId = "ca-app-pub-XXXX/INTERSTITIAL",
    configId = "level_end_interstitial",
    callback = object : FloxisLoadCallback<FloxisInterstitialAd> {
        override fun onAdLoaded(ad: FloxisInterstitialAd) { interstitial = ad }
        override fun onAdFailedToLoad(error: LoadAdError, auction: AuctionOutcome) { }
    },
)

when (interstitial?.show(this)) {
    FloxisShowResult.EXPIRED, FloxisShowResult.DISABLED -> reloadInterstitial()
    else -> Unit
}

FloxisRewardedAd#

load parameters, in order: context: Context, adMobAdUnitId: String, configId: String, callback: FloxisLoadCallback<FloxisRewardedAd>, requestFactory: FloxisRequestFactory = FloxisRequestFactory.DEFAULT, videoOptions: FloxisVideoOptions = FloxisVideoOptions().

The order differs from the interstitial: requestFactory comes before the options. From Java, pass FloxisRequestFactory.DEFAULT to reach videoOptions.

Rewarded is video only. A rewarded video bid with neither a click-through nor an end card is declined: the auction ends NO_BID and FLX-204 is logged.

FloxisRewardedAd.load(this, "ca-app-pub-XXXX/REWARDED", "rewarded_main", callback)

rewarded?.show(this, { reward -> grant(reward) })

FloxisRewardedAd.load(this, "ca-app-pub-XXXX/REWARDED", "rewarded_main", callback,
    FloxisRequestFactory.DEFAULT, new FloxisVideoOptions(null, 30));

Android: Next-Gen (floxis-sdk-nextgen)#

Package com.floxis.sdk.nextgen, plus the shared types in com.floxis.sdk. Built on com.google.android.libraries.ads.mobile.sdk:ads-mobile-sdk 1.5.0. Minimum Android SDK 24; compileSdk 35. Cannot share an app with floxis-sdk or floxis-sdk-gam.

Pass Next-Gen's MobileAds.initialize an Activity, or call it from Application.onCreate. Then call Floxis.initialize on the main thread.

FloxisNextGenRequestCustomizer#

public fun interface FloxisNextGenRequestCustomizer {
    public fun customize(builder: BaseAdRequestBuilder<*>)
    // companion: @JvmField val NONE: FloxisNextGenRequestCustomizer
}

Adds your own targeting to each Next-Gen request. It receives a fresh builder already bound to the ad unit ID (and size, for banners). Floxis then sets its adapter extras. When personalised ads are off it also replaces the Google extras bundle with one holding only npa = 1. NONE changes nothing.

FloxisNextGenLoadCallback#

public interface FloxisNextGenLoadCallback<T> {
    public fun onAdLoaded(ad: T)
    public fun onAdFailedToLoad(error: LoadAdError, auction: AuctionOutcome)
}

LoadAdError is com.google.android.libraries.ads.mobile.sdk.common.LoadAdError. Called on the main thread, unlike raw Next-Gen load callbacks.

FloxisNextGenBannerListener#

public interface FloxisNextGenBannerListener {
    public fun onBannerLoaded(ad: BannerAd)
    public fun onBannerFailedToLoad(error: LoadAdError, auction: AuctionOutcome)
}

Called on the main thread after every banner load, refreshes included.

FloxisNextGenBannerAd#

public class FloxisNextGenBannerAd(
    adView: AdView,
    adMobAdUnitId: String,
    adSize: AdSize,
    configId: String,
    sizes: List<FloxisSize>,
    refreshIntervalSeconds: Int = DEFAULT_REFRESH_SECONDS,
    listener: FloxisAuctionListener? = null,
    loadListener: FloxisNextGenBannerListener? = null,
    eventCallback: BannerAdEventCallback? = null,
)

Refresh follows the same rules as FloxisBannerAd. When a refresh replaces a banner, Floxis destroys the old BannerAd.

val banner = FloxisNextGenBannerAd(
    adView = adView,
    adMobAdUnitId = "ca-app-pub-XXXX/BANNER",
    adSize = AdSize.BANNER,
    configId = "home_banner",
    sizes = listOf(FloxisSize(320, 50)),
)
banner.load()

FloxisNextGenInterstitialAd#

load parameters, in order: context: Context, adMobAdUnitId: String, configId: String, callback: FloxisNextGenLoadCallback<FloxisNextGenInterstitialAd>, options: FloxisInterstitialOptions = FloxisInterstitialOptions(), customizer: FloxisNextGenRequestCustomizer = FloxisNextGenRequestCustomizer.NONE.

FloxisNextGenRewardedAd#

load parameters, in order: context: Context, adMobAdUnitId: String, configId: String, callback: FloxisNextGenLoadCallback<FloxisNextGenRewardedAd>, customizer: FloxisNextGenRequestCustomizer = FloxisNextGenRequestCustomizer.NONE, videoOptions: FloxisVideoOptions = FloxisVideoOptions().

rewarded?.show(this, { reward -> runOnUiThread { grant(reward) } })

Android: Google Ad Manager (floxis-sdk-gam)#

Available from the next release; contact your Floxis account manager for early access.

Package com.floxis.sdk.gam, plus the shared types. Built on play-services-ads 25.5.0, Prebid Mobile 3.4.0 and Prebid's GAM event handlers 3.4.0. Minimum Android SDK 24; compileSdk 35. Cannot share an app with floxis-sdk-nextgen.

Each wrapper runs a Floxis auction, then a GAM request that carries the bid. If the Floxis line item wins, Prebid renders the Floxis creative; otherwise GAM's ad shows. Listeners are Prebid's own rendering listeners (org.prebid.mobile.api.rendering.listeners.*). There is no FloxisAuctionListener: read the bid from view.bidResponse or adUnit.bidResponse in onAdLoaded.

Rules for all three classes:

• One load per wrapper. Create a new wrapper for each ad request. A second load() fails with AdException(INTERNAL_ERROR, "GAM ad slot already loaded; create a new wrapper for each request").
• When Floxis is disabled, not initialised or personalised ads are off, the wrapper skips the auction and sends a plain GAM request.
• When personalised ads are off, npa=1 is added to the GAM request after your requestConfiguration runs.
• After destroy(), no listener call reaches your app.
• requestConfiguration is Prebid's AdManagerRequestConfiguration, a single method configure(builder: AdManagerAdRequest.Builder) called for each GAM request.
• Every constructor throws if gamAdUnitId or configId is blank.

FloxisGamBannerAd#

public class FloxisGamBannerAd(
    context: Context,
    gamAdUnitId: String,
    configId: String,
    sizes: List<FloxisSize>,
    listener: BannerViewListener,
    requestConfiguration: AdManagerRequestConfiguration? = null,
)

sizes must not be empty. There is no built-in refresh: create a new wrapper to refresh.

val banner = FloxisGamBannerAd(this, "/1234/home_banner", "home_banner", listOf(FloxisSize(320, 50)),
    object : BannerViewListener {
        override fun onAdLoaded(bannerView: BannerView) { }
        override fun onAdDisplayed(bannerView: BannerView) { }
        override fun onAdFailed(bannerView: BannerView, exception: AdException) { }
        override fun onAdClicked(bannerView: BannerView) { }
        override fun onAdClosed(bannerView: BannerView) { }
    })
container.addView(banner.view)
banner.load()

FloxisGamInterstitialAd#

public class FloxisGamInterstitialAd(
    activity: Activity,
    gamAdUnitId: String,
    configId: String,
    options: FloxisInterstitialOptions = FloxisInterstitialOptions(),
    listener: InterstitialAdUnitListener,
    requestConfiguration: AdManagerRequestConfiguration? = null,
)

In Kotlin, name listener when you leave out options. Java also has a four-argument constructor (activity, gamAdUnitId, configId, listener).

FloxisGamRewardedAd#

public class FloxisGamRewardedAd(
    activity: Activity,
    gamAdUnitId: String,
    configId: String,
    listener: RewardedAdUnitListener,
    requestConfiguration: AdManagerRequestConfiguration? = null,
    videoOptions: FloxisVideoOptions = FloxisVideoOptions(),
)

Grant the reward only from onUserEarnedReward. onAdClosed reaches your listener at most once. A rewarded video bid that cannot render is withheld from GAM and FLX-204 is logged; if GAM then has no fill, onAdFailed receives a NO_BIDS error.

Android: AppLovin MAX (floxis-sdk-max)#

Available from the next release; contact your Floxis account manager for early access.

Package com.floxis.sdk.max, plus the shared types. Built on com.applovin:applovin-sdk 13.1.0, Prebid Mobile 3.4.0 and Prebid's MAX adapters 3.4.0. Minimum Android SDK 24; compileSdk 35. Can share an app with every other Floxis artifact.

Initialise the AppLovin SDK after Floxis.initialize calls back: the Prebid MAX adapter needs Prebid ready first. Each wrapper runs a Floxis auction, then calls loadAd() on your MAX object whatever the auction result, so your other MAX networks still compete. MAX's own listeners report load, show, hide and reward.

FloxisMaxBannerAd#

public class FloxisMaxBannerAd(
    adView: MaxAdView,
    configId: String,
    size: FloxisSize,
    refreshIntervalSeconds: Int = DEFAULT_REFRESH_SECONDS,
    listener: FloxisAuctionListener? = null,
)

• size must be FloxisSize(320, 50) (banner) or FloxisSize(300, 250) (MREC), or the constructor throws. Create an MREC view with MaxAdView(adUnitId, MaxAdFormat.MREC, context).
• The constructor stops MAX auto-refresh on adView. Floxis owns refresh: 60 seconds by default, 0 or less turns it off, other values are clamped to 30..120, with the same visibility rules as FloxisBannerAd.

FloxisMaxInterstitialAd#

public class FloxisMaxInterstitialAd(
    context: Context,
    ad: MaxInterstitialAd,
    configId: String,
    options: FloxisInterstitialOptions = FloxisInterstitialOptions(),
)

Keep one wrapper per MAX ad object and call load() again to reload. Show with MAX's own showAd.

FloxisMaxRewardedAd#

public class FloxisMaxRewardedAd(
    context: Context,
    ad: MaxRewardedAd,
    configId: String,
    videoOptions: FloxisVideoOptions = FloxisVideoOptions(),
)

Same load and cancel as the interstitial. Grant the reward only from MAX's onUserRewarded. A rewarded video bid that cannot render is declined before MAX sees it: the auction ends NO_BID and FLX-204 is logged.

val rewarded = MaxRewardedAd.getInstance("YOUR_MAX_UNIT", this)
rewarded.setListener(maxListener)
val loader = FloxisMaxRewardedAd(this, rewarded, "rewarded_main")
loader.load { outcome -> Log.d("Floxis", "$outcome") }

Android: Unity LevelPlay (floxis-sdk-levelplay)#

Available from the next release; contact your Floxis account manager for early access.

A LevelPlay custom network adapter. You never call it: LevelPlay loads its classes once you add the Floxis custom network with the network key your account manager gives you. Add com.unity3d.ads-mediation:mediation-sdk 9.6.1 and org.jetbrains.kotlinx:kotlinx-coroutines-android 1.10.1 to your app. The adapter is built on floxis-sdk-common and exposes it and Prebid Mobile core 3.4.0 as API dependencies, so your code can call TargetingParams without adding Prebid Mobile. It does not use FloxisConfig or Floxis.*.

Classes LevelPlay loads#

FloxisCustomAdapter.getAdapterVersion() returns the Floxis SDK version and getNetworkSDKVersion() returns the Prebid Mobile version. LevelPlay shows both in its tools.

Network parameters#

Values may be entered as text or numbers. Use the same seat and region as any other Floxis artifact in the app.

Behaviour#

• Formats. Banner at any LevelPlay size (a smart banner becomes 728x90 on screens wider than 720 dp, otherwise 320x50; LevelPlay drives refresh), display interstitial, and rewarded video.
• Consent. No auction runs after LevelPlay.setConsent(false), when GDPR applies without a TC string or Purpose 1 consent, after a US Privacy opt-out, or when an applicable GPP US section records an opt-out of sale, sharing or targeted advertising. LevelPlay does not pass its CCPA or COPPA settings to custom networks, so the adapter reads the IAB keys your consent tool writes. COPPA does not block the auction: set TargetingParams.setSubjectToCOPPA(true) and it is sent with the request.
• Signals. Every auction carries the device and session signals described in SDK privacy and consent. The adapter shares one session with the other Floxis artifacts in the app.
• Location. Never sent.
• Expiry. isAdAvailable and showAd check consent again and refuse a bid past its expiry (300 seconds unless the bid says otherwise).
• Rewards. The reward and the close are each reported once.

Load and init failures#

A Floxis no-bid reaches LevelPlay as ADAPTER_ERROR_TYPE_NO_FILL with code 10001.

iOS (FloxisSDK, FloxisSDKCore)#

Not yet published. Available from the next release; contact your Floxis account manager for early access.

A Swift package with two products. FloxisSDKCore holds configuration and value types with no dependencies. FloxisSDK holds the ad wrappers and depends on Prebid Mobile iOS 3.4.0, Prebid's AdMob adapters and Google Mobile Ads 13.8.0 or newer (below 14). Minimum iOS 15, Swift 5.9.

FloxisSDK does not re-export FloxisSDKCore, so import both. Import PrebidMobile too if you set Prebid targeting such as Targeting.shared.subjectToCOPPA.

import FloxisSDK
import FloxisSDKCore
import GoogleMobileAds

Floxis#

@MainActor public final class Floxis. Use Floxis.shared.

initialize

• Call it after Google Mobile Ads has started and your consent tool has run.
• A second call with a different seat or region reports .failed with "Floxis is already configured for another seat or region". A second call with the same seat and region takes its other settings. If start-up already succeeded, it reports that result; otherwise it starts again.
• With enabled: false it reports .disabled.
• Start-up gives up after 12 seconds. A later ad load retries a failed start-up, at most once every 30 seconds.
• The completion may run before initialize returns.

let configuration = try FloxisConfiguration(seat: "YOUR_SEAT", region: "us-e")
Floxis.shared.initialize(configuration) { status, detail in
    print("Floxis init: \(status) \(detail ?? "")")
}

FloxisDiagnostic has code: String and message: String. See the code table below.

FloxisSDKError:

FloxisConfiguration (FloxisSDKCore)#

public init(seat: String, region: String = "us-e", timeoutMs: Int = 1_500, debug: Bool = false,
            testMode: Bool = false, enabled: Bool = true, personalizedAds: Bool = true,
            storeURL: URL? = nil, shareLocation: Bool = true) throws

The fields match Android's FloxisConfig, with these differences:

• storeURL must be an https URL with a host, for example https://apps.apple.com/app/id123456789.
• debug writes Floxis <code> <message> lines to the Xcode console.
• testMode takes effect only in the Simulator or in a build signed with a development profile. App Store, TestFlight, ad hoc and enterprise builds ignore it and report FLX-105.
• shareLocation sends a location only when the app already has location authorization. It follows Android's rules: no location for a child-directed request, when GDPR applies without TCF special feature 1, or after a US Privacy or GPP US opt-out.

The initializer throws FloxisConfigurationError: .invalidSeat, .invalidRegion, .invalidTimeout or .invalidStoreURL. .invalidConfigID is thrown by requestConfiguration for a placement ID that is empty or longer than 128 characters; a wrapper reports it as an auction .error and still loads Google.

FloxisBannerAd#

public init(configID: String, size: CGSize, bannerView: GoogleMobileAds.BannerView,
            refreshIntervalSeconds: Int = 60)

Set the banner view's ad unit ID and root view controller yourself, and turn off AdMob's automatic refresh.

let bannerView = BannerView(adSize: AdSizeBanner)
bannerView.adUnitID = "ca-app-pub-XXXX/BANNER"
bannerView.rootViewController = self
let banner = FloxisBannerAd(configID: "home_banner", size: CGSize(width: 320, height: 50), bannerView: bannerView)
banner.load { outcome in print(outcome.status, outcome.priceBucket ?? "") }

FloxisInterstitialAd and FloxisRewardedAd#

// FloxisInterstitialAd
public init(configID: String, adMobUnitID: String, format: FloxisInterstitialFormat = .displayAndVideo,
            videoOptions: FloxisVideoOptions = FloxisVideoOptions())
// FloxisRewardedAd
public init(configID: String, adMobUnitID: String, videoOptions: FloxisVideoOptions = FloxisVideoOptions())

A loaded ad expires one hour after it loads. Keep the wrapper alive until the ad is dismissed.

let rewarded = FloxisRewardedAd(configID: "rewarded_main", adMobUnitID: "ca-app-pub-XXXX/REWARDED")
rewarded.load { outcome, error in print(outcome.status, error as Any) }
if rewarded.isReady {
    _ = rewarded.show(from: self) { grantReward() }
}

FloxisInterstitialFormat and FloxisVideoOptions#

FloxisInterstitialFormat is .display, .video or .displayAndVideo, as on Android.

FloxisVideoOptions(minDurationSeconds: Int? = nil, maxDurationSeconds: Int? = nil, skippable: Bool? = nil) works as on Android, but does not validate its values.

FloxisAuctionOutcome and FloxisAuctionStatus (FloxisSDKCore)#

FloxisAuctionOutcome has status, priceBucket: String?, latencyMs: Int and detail: String?. It has no response ID. FloxisAuctionStatus is .bid, .noBid, .timeout, .error, .skippedDisabled, .skippedNoConsent or .skippedNotInitialized, with the same meanings as Android.

Other FloxisSDKCore types#

These public types build the auction request. Most apps never use them.

The SDK sends device and session signals, and the muted state behind video playbackmethod, only when personalised ads are on, GDPR does not apply or the TC string grants Purpose 1, and neither the US Privacy string nor an applicable GPP US section records an opt-out. Battery level and charging state appear only when your app has turned on UIDevice.current.isBatteryMonitoringEnabled. Before each auction the SDK copies Google Mobile Ads' child-directed setting into Targeting.shared.subjectToCOPPA; when that setting is unspecified, the value you set is kept.

Log and diagnostic codes#

Android logs under the logcat tag Floxis (adb logcat -s Floxis). Warnings always log; debug lines log only with debug = true. iOS sends every code to Floxis.shared.onDiagnostic, and to the console with debug: true.

Unity LevelPlay has no log tag. Its results arrive as LevelPlay callback messages (see the LevelPlay section).

Platform differences#

Related guides#

• In-app SDK (Android): setup for floxis-sdk and floxis-sdk-nextgen.
• In-app SDK (iOS, AdMob): setup for the Swift package.
• In-app SDK (Google Ad Manager), In-app SDK (AppLovin MAX) and In-app SDK (Unity LevelPlay): setup for each mediation path.
• SDK privacy and consent: what the SDK reads and sends, and when.
• SDK testing and troubleshooting: test mode, logs and common issues.
• SDK release notes: what changed in each version.