YandexBannerSizeHelper.cs

using UnityEngine;
using YandexMobileAds;
using YandexMobileAds.Base;
 
namespace SCG.SpaceAdMobile
{
    internal static class YandexBannerSizeHelper
    {
        private const int AdaptiveMinHeightDp = 50;

        private const float AdaptiveMaxScreenHeightMultiplier = 0.15f;

        private const float AdaptiveBaselineHeightToWidthRatio = 50f / 320f;

        private const float RuntimeSizeToleranceMultiplier = 1.1f;

        public static BannerAdSize CreateRuntimeBannerSize(BannerOptions bannerOptions)
        {
            var width = GetBannerWidthDp(bannerOptions);
#if !LEGACY_YANDEX_MOBILE_ADS
            return bannerOptions.Type == BannerType.Inline
                ? BannerAdSize.Inline(width, bannerOptions.InlineMaxHeight)
                : BannerAdSize.Sticky(width);
#else
            return bannerOptions.Type == BannerType.Inline
                ? BannerAdSize.InlineSize(width, bannerOptions.InlineMaxHeight)
                : BannerAdSize.StickySize(width);
#endif
        }

        public static float GetBannerHeightPixels(
            BannerOptions bannerOptions,
            BannerAdSize runtimeBannerSize,
            float adaptiveReserveBias) =>
            bannerOptions.Type == BannerType.Inline
                ? GetEstimatedInlineHeightPixels(bannerOptions, adaptiveReserveBias)
                : GetEstimatedStickyHeightPixels(bannerOptions, runtimeBannerSize, adaptiveReserveBias);

        public static float GetBannerWidthPixels(BannerOptions bannerOptions, BannerAdSize runtimeBannerSize)
        {
            var runtimeWidth = GetRuntimeBannerWidthPixels(runtimeBannerSize);
            return runtimeWidth > 0f
                ? runtimeWidth
                : GetConfiguredBannerWidthPixels(bannerOptions);
        }

        private static float GetScreenWidthPixels() => Screen.safeArea.width > 0f
            ? Screen.safeArea.width
            : Screen.width;

        private static float GetScreenHeightPixels() => Screen.safeArea.height > 0f
            ? Screen.safeArea.height
            : Screen.height;

        private static int GetScreenWidthDp() => ScreenUtils.ConvertPixelsToDp((int)GetScreenWidthPixels());

        private static float ConvertDpToPixels(int dp)
        {
            if (dp <= 0)
                return 0f;
 
            var safeAreaWidthDp = GetScreenWidthDp();
            return safeAreaWidthDp > 0
                ? dp * (GetScreenWidthPixels() / safeAreaWidthDp)
                : dp;
        }

        private static int GetBannerWidthDp(BannerOptions bannerOptions) => bannerOptions.Width < 0
            ? GetScreenWidthDp()
            : bannerOptions.Width;

        private static float GetConfiguredBannerWidthPixels(BannerOptions bannerOptions) => bannerOptions.Width > 0
            ? ConvertDpToPixels(bannerOptions.Width)
            : GetScreenWidthPixels();

        private static float ConvertRuntimeDimensionToPixels(int value, float maxPixels)
        {
            if (value <= 0 || maxPixels <= 0f)
                return 0f;
 
            var convertedValue = ConvertDpToPixels(value);
            if (convertedValue <= maxPixels * RuntimeSizeToleranceMultiplier)
                return convertedValue;
 
            return value <= maxPixels * RuntimeSizeToleranceMultiplier
                ? value
                : 0f;
        }

        private static float GetRuntimeBannerWidthPixels(BannerAdSize bannerSize) =>
            bannerSize is not { Width: > 0 }
                ? 0f
                : ConvertRuntimeDimensionToPixels(bannerSize.Width, GetScreenWidthPixels());

        private static float GetRuntimeStickyHeightPixels(BannerAdSize bannerSize)
        {
            if (bannerSize is not { Height: > 0 })
                return 0f;
 
            var minHeight = GetAdaptiveMinHeightPixels();
            var maxHeight = GetAdaptiveMaxHeightPixels();
            var runtimeHeight = ConvertRuntimeDimensionToPixels(bannerSize.Height, maxHeight);
 
            return runtimeHeight > 0f
                ? ClampAdaptiveHeightPixels(runtimeHeight, minHeight, maxHeight)
                : 0f;
        }

        private static float GetAdaptiveMinHeightPixels() => ConvertDpToPixels(AdaptiveMinHeightDp);

        private static float GetAdaptiveMaxHeightPixels() =>
            GetScreenHeightPixels() * AdaptiveMaxScreenHeightMultiplier;

        private static float GetInlineReserveMaxHeightPixels(BannerOptions bannerOptions)
        {
            var screenMaxHeight = GetAdaptiveMaxHeightPixels();
 
            var configuredMaxHeight = ConvertDpToPixels(bannerOptions.InlineMaxHeight);
            return configuredMaxHeight > 0f
                ? Mathf.Min(screenMaxHeight, configuredMaxHeight)
                : screenMaxHeight;
        }

        private static float ClampAdaptiveHeightPixels(float height, float minHeight, float maxHeight) =>
            maxHeight <= 0f ? Mathf.Max(0f, height) :
            minHeight > maxHeight ? maxHeight : Mathf.Clamp(height, minHeight, maxHeight);

        private static float EstimateAdaptiveHeightPixels(
            BannerOptions bannerOptions,
            float maxHeightPixels,
            float adaptiveReserveBias)
        {
            var width = GetBannerWidthPixels(bannerOptions, null);
            var minHeight = GetAdaptiveMinHeightPixels();
            var widthBasedHeight = width * AdaptiveBaselineHeightToWidthRatio;
            var reserveBias = Mathf.Clamp01(adaptiveReserveBias);
            var biasedHeight = Mathf.Lerp(widthBasedHeight, maxHeightPixels, reserveBias);
 
            return ClampAdaptiveHeightPixels(biasedHeight, minHeight, maxHeightPixels);
        }

        private static float GetEstimatedInlineHeightPixels(BannerOptions bannerOptions, float adaptiveReserveBias) =>
            EstimateAdaptiveHeightPixels(
                bannerOptions,
                GetInlineReserveMaxHeightPixels(bannerOptions),
                adaptiveReserveBias);

        private static float GetEstimatedStickyHeightPixels(
            BannerOptions bannerOptions,
            BannerAdSize runtimeBannerSize,
            float adaptiveReserveBias)
        {
            var runtimeHeight = GetRuntimeStickyHeightPixels(runtimeBannerSize);
            return runtimeHeight > 0f
                ? runtimeHeight
                : EstimateAdaptiveHeightPixels(bannerOptions, GetAdaptiveMaxHeightPixels(), adaptiveReserveBias);
        }
    }
}