Trusted Arbiter

private CloudXArbiterResult _nextWinner;

// Runs as soon as the candidates have settled, ahead of the placement.
private void PrepareWinner(IReadOnlyList<CloudXArbiterBid> bids)
{
    CloudXSdk.Arbiter(bids, result => _nextWinner = result);
}

// Runs at the placement. No network call here.
private void ShowInterstitial(string placement)
{
    switch (_nextWinner?.Platform)
    {
        case CloudXArbiterPlatform.CloudX:
            CloudXSdk.ShowInterstitial("YOUR_CLOUDX_AD_UNIT_ID", placement);
            break;
        case CloudXArbiterPlatform.AdMob:
            adMobInterstitial.Show();
            break;
        default:
            break; // no winner prepared; continue without an ad
    }

    _nextWinner = null;
}

using System.Collections.Generic;
using CloudX;
using UnityEngine;

// cloudXAd is the CloudXAd from a CloudX OnAdLoadSuccess callback.
// Its AdValues map carries the trusted-payload keys the server uses to validate the bid.
// levelPlayNetwork / levelPlayRevenue / levelPlayPrecision come from the Unity LevelPlay ad info.
// pubMaticPrice and pubMaticPartner come from the PubMatic/OpenWrap bid object.
var bids = new List<CloudXArbiterBid>
{
    new CloudXArbiterBid.CloudX(cloudXAd),
    new CloudXArbiterBid.LevelPlay(
        NetworkName: levelPlayNetwork,
        Revenue: levelPlayRevenue,
        Precision: levelPlayPrecision),
    new CloudXArbiterBid.PubMatic(
        Price: pubMaticPrice,
        PartnerName: pubMaticPartner),
};

CloudXSdk.Arbiter(bids, result =>
{
    Debug.Log($"Selected platform: {result.Platform}");
});

private static CloudXRevenuePrecision ToCloudXRevenuePrecision(AdValue.PrecisionType precision) => precision switch
{
    AdValue.PrecisionType.Precise => CloudXRevenuePrecision.Exact,
    AdValue.PrecisionType.Estimated => CloudXRevenuePrecision.Estimated,
    AdValue.PrecisionType.PublisherProvided => CloudXRevenuePrecision.PublisherDefined,
    _ => CloudXRevenuePrecision.Undefined,
};

private static bool ReportGooglePaidEvent(
    CloudXRevenuePlatform platform,
    AdValue adValue,
    string adFormat,
    string adUnitId)
{
    // adValue.Value is in micro-units of adValue.CurrencyCode.
    return CloudXSdk.ReportRevenueData(new CloudXRevenueData(
        Platform: platform,
        Revenue: adValue.Value / 1_000_000.0,
        AdFormat: adFormat,
        CurrencyCode: adValue.CurrencyCode,
        Precision: ToCloudXRevenuePrecision(adValue.Precision),
        AdUnitId: adUnitId));
}

// AdMob ad that competed in the arbitration.
adMobInterstitial.OnAdPaid += adValue =>
{
    ReportGooglePaidEvent(CloudXRevenuePlatform.AdMob, adValue, "interstitial", adMobAdUnitId);
};

// Ad Manager ad that competed in the arbitration.
adManagerInterstitial.OnAdPaid += adValue =>
{
    ReportGooglePaidEvent(CloudXRevenuePlatform.Gam, adValue, "interstitial", adManagerAdUnitId);
};

// NetworkName is optional; pass the winning ad source when you know it.
var adMobBid = new CloudXArbiterBid.AdMob(
    AdUnitId: adMobAdUnitId,
    NetworkName: adMobNetworkName ?? "admob");

// An Ad Manager ad unit id takes the form /NNNNNNN/placement/name.
var adManagerBid = new CloudXArbiterBid.Gam(AdUnitId: "/21775744923/example/interstitial");

var bids = new List<CloudXArbiterBid>
{
    new CloudXArbiterBid.CloudX(cloudXAd),
    adMobBid,
    adManagerBid,
};

// Runs once the candidates have settled, ahead of the placement.
CloudXSdk.Arbiter(bids, result => _nextWinner = result);

private CloudXArbiterResult _nextWinner;

private void ShowInterstitial(string placement)
{
    switch (_nextWinner?.Platform)
    {
        case CloudXArbiterPlatform.CloudX:
            CloudXSdk.ShowInterstitial("YOUR_CLOUDX_AD_UNIT_ID", placement);
            break;
        case CloudXArbiterPlatform.AdMob:
            adMobInterstitial.Show();
            break;
        case CloudXArbiterPlatform.Gam:
            adManagerInterstitial.Show();
            break;
        default:
            break; // no winner prepared; continue without an ad
    }

    _nextWinner = null;
}

var adMobBid = new CloudXArbiterBid.AdMob(
    AdUnitId: adMobAdUnitId,
    NetworkName: adMobNetworkName ?? "admob",
    // AdValue.Value is in micros: 1,000,000 micros is one currency unit.
    // Do not also divide by 1,000 — this is already a per-impression value, not a CPM.
    ManualRevenuePerImpressionUSD: preBidAdValue.Value / 1_000_000.0);

using System.Collections.Generic;
using CloudX;
using UnityEngine;

/// <summary>
/// Prepares a Trusted Arbiter winner ahead of time so an interstitial can be shown
/// instantly when a placement is reached.
///
/// Loads the CloudX and LevelPlay interstitials in parallel, waits until both have
/// finished loading or failing, submits the loaded candidates to CloudXSdk.Arbiter,
/// and caches the selected CloudXArbiterPlatform in _nextWinner.
/// </summary>
public class ArbiterInterstitialController : MonoBehaviour
{
    private const string CloudXAdUnitId = "interstitial_main";

    // Set by the host once the LevelPlay Unity SDK reports a loaded interstitial.
    public string LevelPlayNetwork;
    public double LevelPlayRevenue;
    public string LevelPlayPrecision;

    // Invoked once the arbiter has selected a platform for the next show.
    public System.Action<CloudXArbiterPlatform> OnWinnerPrepared;

    private CloudXAd _cloudXAd;
    private bool _cloudXLoadDone;
    private bool _levelPlayLoaded;
    private bool _levelPlayLoadDone;
    private CloudXArbiterPlatform? _nextWinner;

    private void OnEnable()
    {
        CloudXAdsCallbacks.Interstitial.OnAdLoadSuccess += OnCloudXLoaded;
        CloudXAdsCallbacks.Interstitial.OnAdLoadFailed += OnCloudXLoadFailed;
        CloudXAdsCallbacks.Interstitial.OnAdHidden += OnCloudXHidden;
        CloudXAdsCallbacks.Interstitial.OnAdShowFailed += OnCloudXShowFailed;
    }

    private void OnDisable()
    {
        CloudXAdsCallbacks.Interstitial.OnAdLoadSuccess -= OnCloudXLoaded;
        CloudXAdsCallbacks.Interstitial.OnAdLoadFailed -= OnCloudXLoadFailed;
        CloudXAdsCallbacks.Interstitial.OnAdHidden -= OnCloudXHidden;
        CloudXAdsCallbacks.Interstitial.OnAdShowFailed -= OnCloudXShowFailed;
    }

    /// <summary>Starts a load for each platform that does not currently hold a cached ad.</summary>
    public void LoadMissingAds()
    {
        if (_cloudXAd == null) CloudXSdk.LoadInterstitial(CloudXAdUnitId);
        if (!_levelPlayLoaded) LoadLevelPlayInterstitial();
    }

    /// <summary>
    /// Shows the prepared winner, returning true only when a show call was made.
    ///
    /// Returns false when no winner is ready or the cached ad is no longer available, in which
    /// case a fresh load cycle is started.
    /// </summary>
    public bool ShowAtPlacement(string placement)
    {
        switch (_nextWinner)
        {
            case CloudXArbiterPlatform.CloudX:
                return ShowCloudX(placement);
            case CloudXArbiterPlatform.LevelPlay:
                return ShowLevelPlay(placement);
            default:
                return false;
        }
    }

    /// <summary>
    /// Runs the arbiter once both platforms have settled, then caches the winning platform.
    ///
    /// Returns early until both loads complete. If neither platform loaded, it restarts the
    /// load cycle; otherwise it submits the loaded candidates to CloudXSdk.Arbiter.
    /// </summary>
    private void MaybePrepareWinner()
    {
        if (!_cloudXLoadDone || !_levelPlayLoadDone) return;

        if (_cloudXAd == null && !_levelPlayLoaded)
        {
            _cloudXLoadDone = false;
            _levelPlayLoadDone = false;
            LoadMissingAds();
            return;
        }

        var bids = new List<CloudXArbiterBid>();
        if (_cloudXAd != null)
        {
            bids.Add(new CloudXArbiterBid.CloudX(_cloudXAd));
        }

        if (_levelPlayLoaded)
        {
            bids.Add(new CloudXArbiterBid.LevelPlay(
                NetworkName: LevelPlayNetwork,
                Revenue: LevelPlayRevenue,
                Precision: LevelPlayPrecision));
        }

        CloudXSdk.Arbiter(bids, result =>
        {
            _nextWinner = result.Platform;
            OnWinnerPrepared?.Invoke(result.Platform);
        });
    }

    private bool ShowCloudX(string placement)
    {
        if (CloudXSdk.IsInterstitialReady(CloudXAdUnitId))
        {
            CloudXSdk.ShowInterstitial(CloudXAdUnitId, placement);
            return true;
        }

        ClearCloudXAndLoadMissingAds();
        return false;
    }

    private bool ShowLevelPlay(string placement)
    {
        if (IsLevelPlayInterstitialReady())
        {
            ShowLevelPlayInterstitial(placement);
            return true;
        }

        ClearLevelPlayAndLoadMissingAds();
        return false;
    }

    private void OnCloudXLoaded(CloudXAd ad)
    {
        _cloudXAd = ad;
        _cloudXLoadDone = true;
        MaybePrepareWinner();
    }

    private void OnCloudXLoadFailed(string adUnitId, CloudXError error)
    {
        _cloudXAd = null;
        _cloudXLoadDone = true;
        MaybePrepareWinner();
    }

    private void OnCloudXHidden(CloudXAd ad) => ClearCloudXAndLoadMissingAds();

    private void OnCloudXShowFailed(CloudXAd ad, CloudXError error) => ClearCloudXAndLoadMissingAds();

    private void ClearCloudXAndLoadMissingAds()
    {
        _cloudXAd = null;
        _cloudXLoadDone = false;
        _nextWinner = null;
        LoadMissingAds();
    }

    private void ClearLevelPlayAndLoadMissingAds()
    {
        _levelPlayLoaded = false;
        _levelPlayLoadDone = false;
        _nextWinner = null;
        LoadMissingAds();
    }

    /*
     * The following members wrap the LevelPlay Unity SDK. Replace the bodies with calls into
     * the LevelPlay SDK you integrate, and route its load callbacks into the fields above:
     * on load success, set _levelPlayLoaded = true and the LevelPlay* values, then set
     * _levelPlayLoadDone = true and call MaybePrepareWinner(); on load failure, set
     * _levelPlayLoaded = false, _levelPlayLoadDone = true, and call MaybePrepareWinner().
     * On ad close or show failure, call ClearLevelPlayAndLoadMissingAds() to drop the
     * consumed ad and start a fresh cycle.
     */
    private void LoadLevelPlayInterstitial() { /* LevelPlay.LoadInterstitial(...) */ }
    private bool IsLevelPlayInterstitialReady() => _levelPlayLoaded;
    private void ShowLevelPlayInterstitial(string placement) { /* LevelPlay.ShowInterstitial(...) */ }
}

using System.Collections.Generic;
using CloudX;
using UnityEngine;

/// <summary>
/// Runs Trusted Arbiter on a recurring interval to decide which of the CloudX or
/// LevelPlay banners is shown for "banner_main".
///
/// Auto-refresh is disabled on both networks so arbitration controls loading and
/// display directly: only the arbiter's winner is ever shown, the loser is kept
/// loaded but hidden, and the winner's own impression triggers its next fill.
/// </summary>
public class ArbiterBannerController : MonoBehaviour
{
    private const string CloudXAdUnitId = "banner_main";
    private const float RefreshIntervalSeconds = 25f;

    // Set by the host once the LevelPlay Unity SDK reports a loaded banner.
    public string LevelPlayNetwork;
    public double LevelPlayRevenue;
    public string LevelPlayPrecision;

    private CloudXAd _cloudXAd;
    private bool _cloudXLoaded;
    private bool _cloudXLoadDone;
    private bool _levelPlayLoaded;
    private bool _levelPlayLoadDone;
    private CloudXArbiterPlatform? _shownPlatform;
    private float _refreshTimer;

    private void OnEnable()
    {
        var config = new CloudXAdViewConfiguration(CloudXAdViewConfiguration.AdViewPosition.BottomCenter);
        CloudXSdk.CreateBanner(CloudXAdUnitId, config);
        CloudXSdk.StopBannerAutoRefresh(CloudXAdUnitId);

        CloudXAdsCallbacks.Banner.OnAdLoadSuccess += OnCloudXLoaded;
        CloudXAdsCallbacks.Banner.OnAdLoadFailed += OnCloudXLoadFailed;
        CloudXAdsCallbacks.Banner.OnAdRevenuePaid += OnCloudXImpression;

        LoadMissingAds();
    }

    private void OnDisable()
    {
        CloudXAdsCallbacks.Banner.OnAdLoadSuccess -= OnCloudXLoaded;
        CloudXAdsCallbacks.Banner.OnAdLoadFailed -= OnCloudXLoadFailed;
        CloudXAdsCallbacks.Banner.OnAdRevenuePaid -= OnCloudXImpression;
    }

    private void Update()
    {
        if (_shownPlatform == null) return;

        _refreshTimer += Time.deltaTime;
        if (_refreshTimer >= RefreshIntervalSeconds)
        {
            _refreshTimer = 0f;
            RunArbiter();
        }
    }

    /// <summary>Starts a load for each network that does not currently hold a filled ad.</summary>
    private void LoadMissingAds()
    {
        if (!_cloudXLoaded) CloudXSdk.LoadBanner(CloudXAdUnitId);
        if (!_levelPlayLoaded) LoadLevelPlayBanner();
    }

    /// <summary>
    /// Submits the currently filled candidates to CloudXSdk.Arbiter and shows only the
    /// winner's view, hiding the loser so it never renders or fires an impression.
    /// </summary>
    private void RunArbiter()
    {
        if (!_cloudXLoadDone || !_levelPlayLoadDone) return;

        var bids = new List<CloudXArbiterBid>();
        if (_cloudXLoaded) bids.Add(new CloudXArbiterBid.CloudX(_cloudXAd));
        if (_levelPlayLoaded)
        {
            bids.Add(new CloudXArbiterBid.LevelPlay(
                NetworkName: LevelPlayNetwork,
                Revenue: LevelPlayRevenue,
                Precision: LevelPlayPrecision));
        }

        if (bids.Count == 0) return;

        CloudXSdk.Arbiter(bids, result =>
        {
            _shownPlatform = result.Platform;
            ShowWinnerHideLoser(result.Platform);
        });
    }

    private void ShowWinnerHideLoser(CloudXArbiterPlatform winner)
    {
        if (winner == CloudXArbiterPlatform.CloudX)
        {
            CloudXSdk.ShowBanner(CloudXAdUnitId);
            HideLevelPlayBanner();
        }
        else if (winner == CloudXArbiterPlatform.LevelPlay)
        {
            CloudXSdk.HideBanner(CloudXAdUnitId);
            ShowLevelPlayBanner();
        }
    }

    private void OnCloudXLoaded(CloudXAd ad)
    {
        _cloudXAd = ad;
        _cloudXLoaded = true;
        _cloudXLoadDone = true;
        RunArbiter();
    }

    private void OnCloudXLoadFailed(string adUnitId, CloudXError error)
    {
        _cloudXLoaded = false;
        _cloudXLoadDone = true;
        RunArbiter();
    }

    /// <summary>
    /// Fires once the shown CloudX banner's impression is confirmed. Immediately starts
    /// loading the next fill from the winning network; the non-winning network's current
    /// fill is retained until the next arbitration round.
    /// </summary>
    private void OnCloudXImpression(CloudXAd ad)
    {
        if (_shownPlatform != CloudXArbiterPlatform.CloudX) return;

        _cloudXLoaded = false;
        _cloudXLoadDone = false;
        CloudXSdk.LoadBanner(CloudXAdUnitId);
    }

    /*
     * The following members wrap the LevelPlay Unity SDK. Replace the bodies with calls
     * into the LevelPlay SDK you integrate, and route its callbacks into the fields above:
     * on load success, set _levelPlayLoaded = true and the LevelPlay* values, then set
     * _levelPlayLoadDone = true and call RunArbiter(); on load failure, set
     * _levelPlayLoaded = false, _levelPlayLoadDone = true, and call RunArbiter(). On the
     * LevelPlay banner's impression callback, when it is the shown platform, set
     * _levelPlayLoaded = false, _levelPlayLoadDone = false, and start its next load —
     * mirroring OnCloudXImpression above. Disable LevelPlay banner auto-refresh alongside
     * CloudX's in OnEnable.
     */
    private void LoadLevelPlayBanner() { /* LevelPlay.LoadBanner(...); disable its auto-refresh */ }
    private void ShowLevelPlayBanner() { /* LevelPlay banner view.Show() */ }
    private void HideLevelPlayBanner() { /* LevelPlay banner view.Hide() */ }
}

var customBid = new CloudXArbiterBid.Custom(
    PlatformName: "my_mediation_platform",
    NetworkName: "winning_demand_source",
    RevenuePerImpressionUSD: 0.00125,
    Precision: "EXACT",
    Extras: new Dictionary<string, string> { ["ad_unit"] = "third-party-ad-unit-id" });

var bids = new List<CloudXArbiterBid>
{
    new CloudXArbiterBid.CloudX(cloudXAd),
    customBid,
};

CloudXSdk.Arbiter(bids, result =>
{
    Debug.Log($"Selected platform: {result.Platform}");
});