Trusted Arbiter

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

// cloudXAd 是 CloudX OnAdLoadSuccess 回调中的 CloudXAd 对象。
// 它的 AdValues 映射携带了服务器用于校验出价的受信任载荷键。
// levelPlayNetwork / levelPlayRevenue / levelPlayPrecision 来自 Unity LevelPlay 广告信息。
// pubMaticPrice 和 pubMaticPartner 来自 PubMatic/OpenWrap 出价对象。
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($"选中的平台: {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 为可选参数；如果你知道获胜的广告来源，请传入它。
var adMobBid = new CloudXArbiterBid.AdMob(
    AdUnitId: adMobAdUnitId,
    NetworkName: adMobNetworkName ?? "admob");

// Ad Manager 广告单元 ID 的格式为 /NNNNNNN/placement/name。
var adManagerBid = new CloudXArbiterBid.Gam(AdUnitId: "/21775744923/example/interstitial");

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

CloudXSdk.Arbiter(bids, result =>
{
    switch (result.Platform)
    {
        case CloudXArbiterPlatform.CloudX:
            CloudXSdk.ShowInterstitial("YOUR_CLOUDX_AD_UNIT_ID", "level_complete");
            break;
        case CloudXArbiterPlatform.AdMob:
            adMobInterstitial.Show();
            break;
        case CloudXArbiterPlatform.Gam:
            adManagerInterstitial.Show();
            break;
    }
});

var adMobBid = new CloudXArbiterBid.AdMob(
    AdUnitId: adMobAdUnitId,
    NetworkName: adMobNetworkName ?? "admob",
    // AdValue.Value 以微单位（micros）表示：1,000,000 微单位等于 1 个货币单位。
    // 请勿再额外除以 1,000——该数值本身已是单次展示的收益，而不是 CPM。
    ManualRevenuePerImpressionUSD: preBidAdValue.Value / 1_000_000.0);

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

/// <summary>
/// 提前准备好 Trusted Arbiter 的获胜平台，以便在到达广告位时立即展示插屏广告。
///
/// 并行加载 CloudX 和 LevelPlay 插屏广告，等待两者都加载完成或加载失败，
/// 将已加载的候选项提交给 CloudXSdk.Arbiter，并将选中的 CloudXArbiterPlatform
/// 缓存到 _nextWinner 中。
/// </summary>
public class ArbiterInterstitialController : MonoBehaviour
{
    private const string CloudXAdUnitId = "interstitial_main";

    // 当 LevelPlay Unity SDK 报告插屏广告已加载时，由宿主设置。
    public string LevelPlayNetwork;
    public double LevelPlayRevenue;
    public string LevelPlayPrecision;

    // 当仲裁器为下一次展示选出平台后调用。
    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>为每个当前没有缓存广告的平台启动加载。</summary>
    public void LoadMissingAds()
    {
        if (_cloudXAd == null) CloudXSdk.LoadInterstitial(CloudXAdUnitId);
        if (!_levelPlayLoaded) LoadLevelPlayInterstitial();
    }

    /// <summary>
    /// 展示已准备好的获胜广告，仅当确实发起了展示调用时返回 true。
    ///
    /// 当没有准备好获胜平台或缓存的广告已不可用时返回 false，
    /// 此时会启动一次新的加载周期。
    /// </summary>
    public bool ShowAtPlacement(string placement)
    {
        switch (_nextWinner)
        {
            case CloudXArbiterPlatform.CloudX:
                return ShowCloudX(placement);
            case CloudXArbiterPlatform.LevelPlay:
                return ShowLevelPlay(placement);
            default:
                return false;
        }
    }

    /// <summary>
    /// 在两个平台都完成后运行仲裁器，然后缓存获胜平台。
    ///
    /// 在两个加载都完成之前提前返回。如果两个平台都没有加载成功，则重启加载周期；
    /// 否则将已加载的候选项提交给 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();
    }

    /*
     * 下面的成员封装了 LevelPlay Unity SDK。请用你集成的 LevelPlay SDK 调用替换其方法体，
     * 并将其加载回调接入上面的字段：加载成功时，设置 _levelPlayLoaded = true 及各个
     * LevelPlay* 值，然后设置 _levelPlayLoadDone = true 并调用 MaybePrepareWinner()；
     * 加载失败时，设置 _levelPlayLoaded = false、_levelPlayLoadDone = true，
     * 并调用 MaybePrepareWinner()。广告关闭或展示失败时，调用
     * ClearLevelPlayAndLoadMissingAds() 以丢弃已消耗的广告并开始新的加载周期。
     */
    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>
/// 按周期性间隔运行 Trusted Arbiter，决定 "banner_main" 应展示 CloudX 还是
/// LevelPlay 的横幅广告。
///
/// 两个广告网络的自动刷新均已关闭，因此加载和展示完全由仲裁结果驱动：
/// 只展示仲裁器选出的获胜广告，未获胜的广告保持已加载但隐藏状态，
/// 获胜广告自身的展示事件会触发它的下一次填充加载。
/// </summary>
public class ArbiterBannerController : MonoBehaviour
{
    private const string CloudXAdUnitId = "banner_main";
    private const float RefreshIntervalSeconds = 25f;

    // 当 LevelPlay Unity SDK 报告横幅广告已加载时，由宿主设置。
    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>为每个当前没有已填充广告的网络启动加载。</summary>
    private void LoadMissingAds()
    {
        if (!_cloudXLoaded) CloudXSdk.LoadBanner(CloudXAdUnitId);
        if (!_levelPlayLoaded) LoadLevelPlayBanner();
    }

    /// <summary>
    /// 将当前已填充的候选项提交给 CloudXSdk.Arbiter，只展示获胜广告的视图，
    /// 并隐藏未获胜的广告，使其永远不会渲染或触发展示事件。
    /// </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>
    /// 在展示中的 CloudX 横幅广告展示事件被确认后触发。立即开始为获胜的广告网络
    /// 加载下一次填充；未获胜广告网络当前的填充广告会保留至下一轮仲裁。
    /// </summary>
    private void OnCloudXImpression(CloudXAd ad)
    {
        if (_shownPlatform != CloudXArbiterPlatform.CloudX) return;

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

    /*
     * 下面的成员封装了 LevelPlay Unity SDK。请用你集成的 LevelPlay SDK 调用替换其方法体，
     * 并将其回调接入上面的字段：加载成功时，设置 _levelPlayLoaded = true 及各个
     * LevelPlay* 值，然后设置 _levelPlayLoadDone = true 并调用 RunArbiter()；
     * 加载失败时，设置 _levelPlayLoaded = false、_levelPlayLoadDone = true，
     * 并调用 RunArbiter()。在 LevelPlay 横幅广告的展示事件回调中，当它是当前展示的
     * 平台时，设置 _levelPlayLoaded = false、_levelPlayLoadDone = false，并开始其
     * 下一次加载——与上面的 OnCloudXImpression 保持一致。请在 OnEnable 中同时关闭
     * LevelPlay 横幅广告的自动刷新。
     */
    private void LoadLevelPlayBanner() { /* LevelPlay.LoadBanner(...); 关闭其自动刷新 */ }
    private void ShowLevelPlayBanner() { /* LevelPlay 横幅视图.Show() */ }
    private void HideLevelPlayBanner() { /* LevelPlay 横幅视图.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($"选中的平台: {result.Platform}");
});