Floxis SDK testing and troubleshooting guide#

This guide helps you check a Floxis SDK integration before release and find out why Floxis ads are not showing. It covers every Floxis SDK: Android with AdMob (classic and Next-Gen), Google Ad Manager, AppLovin MAX and Unity LevelPlay, and iOS with AdMob.

Setup for each integration is in its own guide: In-app SDK (Android), In-app SDK (iOS, AdMob), In-app SDK (Google Ad Manager), In-app SDK (AppLovin MAX) and In-app SDK (Unity LevelPlay). Consent rules are in SDK privacy and consent, and every class and status is listed in SDK API reference.

Only the Android AdMob artifacts (floxis-sdk and floxis-sdk-nextgen) are released today. The Google Ad Manager, AppLovin MAX, Unity LevelPlay and iOS SDKs are available from the next release; contact your Floxis account manager for early access.

How a Floxis ad gets to the screen#

Most problems sit at one of these four steps, so check them in order:

1. Initialise. The SDK connects to the Floxis endpoint for your seat and region. Until this finishes, ad loads skip Floxis and your ad server loads on its own.
2. Auction. Before each load, the SDK asks Floxis for a bid. The result is BID, NO_BID, TIMEOUT, ERROR or a skip.
3. Ad server picks. A winning bid carries its price tier (hb_pb, for example 0.70). Your AdMob Custom Event, Ad Manager line item, MAX placement or LevelPlay instance for that tier has to win in the ad server.
4. Render. The Prebid adapter shows the Floxis creative.

A BID result only proves step 2. Step 3 needs a matching entry for every price tier in your ad server.

1. Turn on test mode and logs#

Android, in a debug build:

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

iOS, in a build you run from Xcode:

let configuration = try FloxisConfiguration(seat: "YOUR_SEAT", region: "us-e", debug: true, testMode: true)
Floxis.shared.onDiagnostic = { diagnostic in print("Floxis", diagnostic.code, diagnostic.message) }
Floxis.shared.initialize(configuration) { status, detail in print("Floxis init:", status, detail ?? "") }

What test mode does:

• It sets the OpenRTB test flag on each auction, which asks buyers to treat the auction as not billable. Not every buyer honours the flag, so keep test builds to test devices. Many buyers do not bid on test traffic, so **few or no Floxis wins in a test build is normal**.
• It only works in a debuggable build. On Android that is a build with android:debuggable set, which debug builds have by default. On iOS it is the Simulator, or a device build signed with a development profile. A release, App Store or TestFlight build ignores testMode and logs FLX-105, so the setting can never send test traffic from production.
• It does not change what the SDK does with a bid. A test win goes through your ad server exactly like a live one.

What debug does:

• Android: turns on the debug log lines below and raises Prebid Mobile's log level to debug. Warnings log even when debug is off.
• iOS: prints every diagnostic to the console. onDiagnostic receives them whether debug is on or off.
• It never changes what is sent to Floxis. Turn it off before release to keep the log quiet.

Before you release, set testMode back to false and remove any test device IDs you added to your ad server SDK.

2. Read the log#

Android#

Every Floxis line has the tag Floxis and starts with a code. Lines marked warning always log; debug lines need debug = true.

A healthy start in a debug build looks like this:

D Floxis  : FLX-100 auction=https://...?seat=YOUR_SEAT status=...
D Floxis  : FLX-101 SUCCEEDED ...
D Floxis  : FLX-200 AuctionOutcome(status=BID, priceBucket=0.70, latencyMs=312, detail=null, responseId=...)
D Floxis  : FLX-200 AuctionOutcome(status=NO_BID, priceBucket=null, latencyMs=280, detail=null, responseId=null)

The AdMob, Next-Gen and MAX SDKs write an FLX-200 line for every auction that runs, and FLX-201 for every skipped one. The Ad Manager SDK writes only the initialisation lines and FLX-204; read its auction result from the Prebid listener instead (see section 3).

To see what Prebid Mobile did as well, filter on both tags:

adb logcat | grep -E "Floxis|PrebidMobile"

iOS#

With debug: true, each diagnostic prints as Floxis <code> <message>. Auction and show messages include the format and your configID.

iOS writes nothing for BID and NO_BID. Read those from the load completion (see section 3).

Unity LevelPlay#

The LevelPlay adapter has no log tag of its own. Every failure reaches LevelPlay's load, show or init callback with a message from section 6. Turn on LevelPlay.setAdaptersDebug(true) in a debug build to see LevelPlay's adapter log.

3. Confirm that Floxis won and rendered#

AdMob on Android (classic and Next-Gen)#

Full-screen ads tell you directly:

override fun onAdLoaded(ad: FloxisInterstitialAd) {
    Log.d("FloxisTest", "auction=${ad.auction.status} tier=${ad.auction.priceBucket} floxisWon=${ad.isFloxisWinner}")
}

FloxisRewardedAd, FloxisNextGenInterstitialAd and FloxisNextGenRewardedAd have the same auction and isFloxisWinner properties.

For a classic banner, use the auction listener and AdMob's own listener on the AdView:

adView.adListener = object : AdListener() {
    override fun onAdLoaded() {
        Log.d("FloxisTest", "served by ${adView.responseInfo?.loadedAdapterResponseInfo?.adapterClassName}")
    }
}

When Floxis won, the class is org.prebid.mobile.admob.PrebidBannerAdapter. For a Next-Gen banner, pass a loadListener to FloxisNextGenBannerAd and read ad.getResponseInfo().loadedAdSourceResponseInfo?.adapterClassName in onBannerLoaded.

AdMob on iOS#

interstitial.load { outcome, error in
    print("auction:", outcome.status, outcome.priceBucket ?? "-", "floxisWon:", interstitial.isFloxisWinner)
}

FloxisRewardedAd works the same way. For a banner, load(completion:) gives you the auction outcome, and the banner's responseInfo?.loadedAdNetworkResponseInfo?.adNetworkClassName ends in PrebidAdMobBannerAdapter when Floxis won. If isFloxisWinner stays false while Ad Inspector shows the Floxis Custom Event filled, tell support your Google Mobile Ads version.

Google Ad Manager#

The Ad Manager SDK uses Prebid Mobile's listeners. In onAdLoaded, the Floxis bid is on the ad unit:

override fun onAdLoaded(interstitialAdUnit: InterstitialAdUnit) {
    val response = interstitialAdUnit.bidResponse
    Log.d("FloxisTest", "Floxis bid=${response?.winningBid?.price ?: "none"} hb_pb=${response?.targeting?.get("hb_pb")}")
}

A banner exposes the same bidResponse on the BannerView in BannerViewListener.onAdLoaded. A bid there means Floxis bid; whether your line item for that tier then won is decided in Ad Manager (section 4).

AppLovin MAX#

The auction listener on load gives the Floxis result, and MAX's own listener tells you which network filled:

FloxisMaxInterstitialAd(this, interstitial, "level_end_interstitial").load { outcome ->
    Log.d("FloxisTest", "auction=${outcome.status} tier=${outcome.priceBucket}")
}

// In your MaxAdListener:
override fun onAdLoaded(ad: MaxAd) {
    Log.d("FloxisTest", "filled by ${ad.networkName} placement ${ad.networkPlacement}")
}

When Floxis won, networkName is the name you gave the Floxis custom network in MAX.

Unity LevelPlay#

A Floxis fill reaches your LevelPlay listener as an ordinary load from the Floxis custom network instance. A Floxis no-bid or privacy block reaches the waterfall as a no-fill, and LevelPlay moves on to the next instance.

In the dashboard (AdMob)#

Open the app's endpoint on the Supply page. Under the integration panel, the AdMob price tier check shows, for each placement and hb_pb tier over the Auction dates (UTC) you pick:

• Returned: bids the device received at this tier.
• Won in AdMob: AdMob called the Custom Event for this tier and the ad loaded.
• Rendered: the creative's impression pixel fired.

A tier flagged Step missing in AdMob got bids but never won, while its neighbours did. That is almost always a missing Custom Event.

4. Use your ad server's debugging tools#

AdMob (and Ad Manager): Ad Inspector#

Ad Inspector shows each ad request, the waterfall and which ad source filled. Open it from a test device:

MobileAds.openAdInspector(activity) { error -> Log.d("FloxisTest", "Ad Inspector closed: $error") }

On Next-Gen, call MobileAds.openAdInspector with an OnAdInspectorClosedListener. On iOS, call MobileAds.shared.presentAdInspector(from: viewController) { error in }.

Register your phone as a test device first, in the AdMob or Ad Manager UI or in code:

MobileAds.setRequestConfiguration(
    RequestConfiguration.Builder().setTestDeviceIds(listOf("YOUR_TEST_DEVICE_ID")).build()
)

On Next-Gen, the same RequestConfiguration.Builder().setTestDeviceIds(...) comes from com.google.android.libraries.ads.mobile.sdk.common. On iOS, set MobileAds.shared.requestConfiguration.testDeviceIdentifiers = ["YOUR_TEST_DEVICE_ID"]. Google prints your device ID in the log the first time an ad loads.

Keep in mind:

• Google's demo ad unit IDs have no Floxis Custom Events, so they can never show a Floxis ad. Test with your own ad units that have the Custom Events from the setup sheet.
• Mediated ads, Floxis included, do not carry Google's "Test Ad" label.
• In Ad Inspector, a Floxis fill shows as the Custom Event row with the label from your setup sheet.

Google Ad Manager: delivery tools#

Use Ad Inspector on the device, and Ad Manager's delivery troubleshooting in the web UI, to see which line item served a request. A Floxis win serves your Floxis line item for that hb_pb tier, and its creative hands the ad back to the SDK to render. If the line item never serves, check its targeting: Floxis sends hb_pb, hb_bidder=floxis, hb_env=mobile-app and, when the bid has a size, hb_size. It never sends hb_format, so a line item that targets hb_format never matches.

AppLovin MAX: Mediation Debugger and test mode#

val config = AppLovinSdkInitializationConfiguration.builder("YOUR_SDK_KEY", this)
    .setMediationProvider(AppLovinMediationProvider.MAX)
    .setTestDeviceAdvertisingIds(listOf("YOUR_GAID"))
    .build()
AppLovinSdk.getInstance(this).settings.setVerboseLogging(true)
AppLovinSdk.getInstance(this).initialize(config) {
    AppLovinSdk.getInstance(this).showMediationDebugger()
}

Run this from the Floxis.initialize callback, whatever its status, as in the In-app SDK (AppLovin MAX) guide: Prebid's MAX adapter needs Floxis initialised first. In the Mediation Debugger, check that MAX found the adapter com.applovin.mediation.adapters.PrebidMaxMediationAdapter for your Floxis custom network. Remove the test device IDs before release.

Unity LevelPlay: integration test suite#

LevelPlay.setMetaData("is_test_suite", "enable")   // before LevelPlay init
LevelPlay.setAdaptersDebug(true)
// after LevelPlay init:
LevelPlay.launchTestSuite(this)

The test suite shows the networks LevelPlay set up for the app. If Floxis is missing, check that the Floxis custom network is added with the network key from your account manager, and that custom adapters are enabled on your LevelPlay account (Unity support enables them). Remove both test settings before release.

5. Common problems#

R8 rules, only if your build skips the rules shipped inside the SDK:

-keep class com.floxis.sdk.** { public *; }
-keep class org.prebid.mobile.admob.** { *; }
-keepnames interface com.floxis.sdk.internal.GmaBridge
-keep class * implements com.floxis.sdk.internal.GmaBridge { <init>(); }

For Ad Manager, add -keep class org.prebid.mobile.eventhandlers.** { *; }. For MAX, add -keep class com.applovin.mediation.adapters.PrebidMaxMediationAdapter { *; }. For LevelPlay, keep the four com.ironsource.adapters.custom.floxis classes listed in the In-app SDK (Unity LevelPlay) guide.

6. Status and error reference#

Auction results (Android AuctionStatus, iOS FloxisAuctionStatus)#

On Android, AuctionOutcome also has latencyMs and, for a BID, responseId. Include the responseId when you contact support about a specific ad.

Initialisation results#

On iOS, calling initialize again with a different seat or region returns .failed with Floxis is already configured for another seat or region.

Full-screen show results (FloxisShowResult)#

These come from show on the AdMob and Next-Gen interstitial and rewarded ads, on Android and iOS. The Ad Manager show() returns true or false, and MAX and LevelPlay report show results through their own listeners.

On Android, a refused show also calls your onAdFailedToShowFullScreenContent with the domain com.floxis.sdk (FloxisShowError.DOMAIN) and the code above. On Next-Gen, the error's code is INTERNAL_ERROR and the Floxis domain and code are on its mediationAdError. Use FloxisShowError.codeFor(result) to compare.

Unity LevelPlay messages#

7. FAQ#

Does test mode cost me or buyers money? Test mode sets the OpenRTB test flag, which asks buyers to treat the auction as not billable. Not every buyer honours it, so run test builds on test devices only. It only works in debuggable builds, so production traffic is never marked as test.

Can I leave debug = true in a release build? It never changes what is sent, but turn it off. On Android it also raises Prebid Mobile's log level, which writes far more to the device log.

Why don't I see a "Test Ad" label on Floxis ads? Google only labels its own test ads. Mediated ads, Floxis included, show the real creative.

Can I test with Google's demo ad units? You can check that the SDK initialises and runs auctions, but a Floxis ad can only show through your own ad units that have the Floxis Custom Events.

The auction says BID, so why is no impression counted? A bid is not an impression. Your ad server must pick the Floxis entry for that tier, and the creative must render. Check the AdMob price tier check and Ad Inspector.

How long can I keep a loaded interstitial or rewarded ad? On Android, until the bid expires (the buyer's expiry, 5 minutes by default). On iOS, one hour. show returns EXPIRED after that.

Do I need to add R8 or ProGuard rules? No, unless your build skips the rules that come inside the SDK.

8. Contact support#

First check that you are on the newest release: https://maven.floxis.tech lists the published versions of each Android artifact.

Email [email protected], or your Floxis account manager. Include:

1. The app's package name or bundle ID, and the endpoint name on the Supply page.
2. The SDK and version (on Android, Floxis.SDK_VERSION returns it; on iOS, Floxis.sdkVersion), and your ad server SDK and version.
3. The platform, device model and OS version.
4. The placement configId and the ad unit ID.
5. A log from app start to the problem, with debug = true:
   • Android: adb logcat -d | grep -E "Floxis|PrebidMobile" > floxis-log.txt
   • iOS: the Xcode console lines starting with Floxis, or your onDiagnostic output.
   • LevelPlay: the load and show callback messages and the LevelPlay adapter log.
6. For a specific ad, the responseId from the auction result and the time it happened, with the time zone.
7. A screenshot of Ad Inspector, the MAX Mediation Debugger or the LevelPlay test suite, if you used one.

Remove user identifiers, consent strings and advertising IDs from logs before you send them.