### Banner Setup

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

In v8, `banner.setAdUnitId(id)` is replaced by passing the ID within the `AdRequest.Builder(id).build()` constructor. Other setup methods remain the same.

```java
banner.setAdUnitId(id)
banner.setAdSize(size)
banner.setBannerAdEventListener(listener)
banner.loadAd(AdRequest.Builder().build())
```

```java
banner.setAdSize(size)
banner.setBannerAdEventListener(listener)
banner.loadAd(AdRequest.Builder(id).build())
```

--------------------------------

### Implement Sticky Banner Ad

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Use `BannerAdView` and `BannerAdSize.sticky()` to create a sticky banner that anchors to the bottom of the screen. Call `BannerAdSize.sticky()` after layout is complete to get accurate dimensions. Remember to destroy the banner ad in `onDestroy()`.

```kotlin
class StickyBannerActivity : AppCompatActivity() {

    private var bannerAd: BannerAdView? = null
    private var bannerAdSize: BannerAdSize? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_sticky_banner)

        val container = findViewById<ConstraintLayout>(R.id.container)
        container.viewTreeObserver.addOnGlobalLayoutListener(object : 
            ViewTreeObserver.OnGlobalLayoutListener {
            override fun onGlobalLayout() {
                container.viewTreeObserver.removeOnGlobalLayoutListener(this)
                val adWidthDp = (container.width / resources.displayMetrics.density).roundToInt()
                bannerAdSize = BannerAdSize.sticky(this@StickyBannerActivity, adWidthDp)
                loadBanner()
            }
        })
    }

    private fun loadBanner() {
        val size = bannerAdSize ?: return
        bannerAd = BannerAdView(this).apply {
            setAdSize(size)
            setBannerAdEventListener(object : BannerAdEventListener {
                override fun onAdLoaded() { Log.d("Ads", "Sticky banner loaded") }
                override fun onAdFailedToLoad(error: AdRequestError) {
                    Log.e("Ads", "Failed: [${error.code}] ${error.description}")
                }
                override fun onAdClicked() { Log.d("Ads", "Clicked") }
                override fun onImpression(data: ImpressionData?) { Log.d("Ads", "Impression") }
            })
            loadAd(AdRequest.Builder("demo-banner-yandex").build())
        }
        // Add to bottom of layout
        val params = ConstraintLayout.LayoutParams(
            size.getWidthInPixels(this),
            size.getHeightInPixels(this)
        ).apply { bottomToBottom = ConstraintLayout.LayoutParams.PARENT_ID }
        findViewById<ConstraintLayout>(R.id.container).addView(bannerAd, params)
    }

    override fun onDestroy() {
        bannerAd?.destroy()
        super.onDestroy()
    }
}
```

--------------------------------

### Ad Show

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

The method for showing interstitial, rewarded, and app open ads remains `ad.show(activity)` in both SDK versions. The event listener setup is also unchanged.

```java
ad.setAdEventListener(listener)
ad.show(activity)
```

```java
ad.setAdEventListener(listener)
ad.show(activity)
```

--------------------------------

### Standard SDK Initialization

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/ThirdPartyMediationAdapterTemplate/README.md

For regular integration, use the standard SDK initialization method provided by the MobileAds class.

```kotlin
MobileAds.initialize(context) {
    onInitializationComplete.invoke()
}
```

--------------------------------

### Initialize SDK

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

Use `YandexAds.initialize(...)` for SDK initialization in v8, replacing `MobileAds.initialize(...)` from v7.

```java
MobileAds.initialize(...)
```

```java
YandexAds.initialize(...)
```

--------------------------------

### Initialize Yandex Ads SDK

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Initialize the SDK in `Application.onCreate()` as early as possible. Set privacy flags before initialization. Ads can only be loaded after the initialization callback fires.

```kotlin
class MyApplication : MultiDexApplication() {
    override fun onCreate() {
        super.onCreate()

        // Set privacy flags BEFORE initializing
        YandexAds.setUserConsent(true)          // GDPR: user has consented
        YandexAds.setLocationTracking(false)    // Disable location-based targeting
        YandexAds.setAgeRestricted(false)       // COPPA: not a child-directed app

        YandexAds.enableLogging(true)           // Verbose logs for debugging

        // Preloading for instream ads (optional, call before initialize)
        YandexInstreamAds.setAdGroupPreloading(true)

        YandexAds.initialize(this) {
            // SDK is ready; start loading ads here
            Log.d("Ads", "SDK initialized, version: ${YandexAds.libraryVersion}")
        }
    }
}
```

--------------------------------

### Gradle Build Command for Migration Check

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

Execute this command after completing the initial migration steps to identify complex cases that require further attention. The output will be logged to build.log.

```bash
./gradlew compileDebugSources 2>&1 | tee build.log
```

--------------------------------

### Configure Privacy Policies

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/ThirdPartyMediationAdapterTemplate/README.md

Set user consent and age restrictions before initializing the SDK. Reinitialize if policies change.

```kotlin
MobileAds.setAgeRestrictedUser(params.isAgeRestrictedUser())
MobileAds.setLocationConsent(params.hasLocationConsent())
MobileAds.setUserConsent(params.hasUserConsent())
```

--------------------------------

### Load and Show Rewarded Ad - Kotlin

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Demonstrates loading and showing a rewarded ad. Ensure `RewardedAdLoadListener` is implemented to handle ad loading callbacks. The `onRewarded` callback delivers reward details upon successful ad completion.

```kotlin
class RewardedActivity : AppCompatActivity(), RewardedAdLoadListener {

    private var rewardedAdLoader: RewardedAdLoader? = null
    private var rewardedAd: RewardedAd? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_rewarded)

        rewardedAdLoader = RewardedAdLoader(this)
        loadAd()

        findViewById<Button>(R.id.show_btn).setOnClickListener { showAd() }
    }

    private fun loadAd() {
        val request = AdRequest.Builder("demo-rewarded-yandex").build()
        rewardedAdLoader?.loadAd(request, this)
    }

    // RewardedAdLoadListener
    override fun onAdLoaded(ad: RewardedAd) {
        rewardedAd = ad
    }

    override fun onAdFailedToLoad(error: AdRequestError) {
        Log.e("Ads", "Load failed [${error.code}]: ${error.description}")
    }

    private fun showAd() {
        rewardedAd?.apply {
            setAdEventListener(object : RewardedAdEventListener {
                override fun onAdShown() {}
                override fun onAdFailedToShow(e: AdError) {}
                override fun onAdDismissed() {
                    rewardedAd?.setAdEventListener(null)
                    rewardedAd = null
                    loadAd()
                }
                override fun onRewarded(reward: Reward) {
                    // Grant in-app currency or unlock content
                    Log.d("Ads", "User earned ${reward.amount} ${reward.type}")
                }
                override fun onAdClicked() {}
                override fun onAdImpression(data: ImpressionData?) {}
            })
            show(this@RewardedActivity)
        }
    }

    override fun onDestroy() {
        rewardedAdLoader?.cancelLoading()
        rewardedAd?.setAdEventListener(null)
        super.onDestroy()
    }
}
```

--------------------------------

### Build Ad Requests with Parameters

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Use `AdRequest.Builder` to construct ad requests, including custom key-value parameters for AdfOX placements or custom targeting, and bidding data for mediation adapters.

```kotlin
// Standard Yandex network request
val standardRequest = AdRequest.Builder("demo-banner-yandex").build()

// AdfOX request with required owner/placement parameters
val adfoxRequest = AdRequest.Builder("R-M-243655-8")
    .setParameters(mapOf(
        "adf_ownerid" to "270901",
        "adf_p1"      to "cqtgh",
        "adf_p2"      to "fkbd"
    ))
    .build()

// Header-bidding request (for mediation adapters)
val biddingRequest = AdRequest.Builder("your-ad-unit-id")
    .setBiddingData(bidderToken) // token obtained from BidderTokenLoader
    .build()
```

--------------------------------

### Ad Request with Custom Parameters

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Demonstrates how to build `AdRequest` objects with custom key-value parameters. This is essential for AdfOX placements and can be used for custom ad targeting.

```APIDOC
## Ad Request with Parameters — `AdRequest.Builder`

`AdRequest.Builder` accepts custom key-value parameters forwarded to the ad server. This is required for AdfOX placements and can be used for custom targeting.

```kotlin
// Standard Yandex network request
val standardRequest = AdRequest.Builder("demo-banner-yandex").build()

// AdfOX request with required owner/placement parameters
val adfoxRequest = AdRequest.Builder("R-M-243655-8")
    .setParameters(mapOf(
        "adf_ownerid" to "270901",
        "adf_p1"      to "cqtgh",
        "adf_p2"      to "fkbd"
    ))
    .build()

// Header-bidding request (for mediation adapters)
val biddingRequest = AdRequest.Builder("your-ad-unit-id")
    .setBiddingData(bidderToken) // token obtained from BidderTokenLoader
    .build()
```
```

--------------------------------

### Load and Bind Custom Native Ad

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Use `NativeAdLoader` to load native ads and `NativeAdViewBinder` to bind ad assets to your custom view layout. Ensure to handle `AdBindingResult.Success` and `AdBindingResult.Failure`.

```kotlin
class NativeAdActivity : AppCompatActivity() {

    private var nativeAdLoader: NativeAdLoader? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_native)
        loadNativeAd()
    }

    private fun loadNativeAd() {
        nativeAdLoader = NativeAdLoader(this)
        val options = NativeAdOptions.Builder()
            .setShouldLoadImagesAutomatically(true)
            .build()
        val request = AdRequest.Builder("demo-native-content-yandex").build()

        nativeAdLoader?.loadAd(request, options, object : NativeAdLoadListener {
            override fun onAdLoaded(nativeAd: NativeAd) {
                bindNativeAd(nativeAd)
            }
            override fun onAdFailedToLoad(error: AdRequestError) {
                Log.e("Ads", "Native failed [${error.code}]: ${error.description}")
            }
        })
    }

    private fun bindNativeAd(nativeAd: NativeAd) {
        val nativeAdView = findViewById<NativeAdView>(R.id.native_ad_view) // your custom ViewGroup
        val binder = NativeAdViewBinder.Builder(nativeAdView)
            .setTitleView(nativeAdView.findViewById(R.id.title))
            .setBodyView(nativeAdView.findViewById(R.id.body))
            .setCallToActionView(nativeAdView.findViewById(R.id.cta_button))
            .setIconView(nativeAdView.findViewById(R.id.icon))
            .setMediaView(nativeAdView.findViewById(R.id.media))
            .setDomainView(nativeAdView.findViewById(R.id.domain))
            .setFaviconView(nativeAdView.findViewById(R.id.favicon))
            .setPriceView(nativeAdView.findViewById(R.id.price))
            .setRatingView(nativeAdView.findViewById(R.id.rating))
            .setSponsoredView(nativeAdView.findViewById(R.id.sponsored))
            .setWarningView(nativeAdView.findViewById(R.id.warning))
            .build()

        when (val result = nativeAd.bindNativeAd(binder)) {
            is AdBindingResult.Success -> {
                nativeAdView.isVisible = true
                nativeAd.setNativeAdEventListener(object : NativeAdEventListener {
                    override fun onAdClicked() { Log.d("Ads", "Native clicked") }
                    override fun onImpression(data: ImpressionData?) {}
                })
            }
            is AdBindingResult.Failure -> {
                Log.e("Ads", "Binding failed: ${result.missingAssetName}")
            }
        }
    }

    override fun onDestroy() {
        nativeAdLoader?.cancelLoading()
        super.onDestroy()
    }
}
```

--------------------------------

### App Open Ad Manager - Kotlin

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Manages app open ads by observing foreground events and activity lifecycles. Preload ads in `Application.onCreate` for immediate display when the app becomes active. Handles ad loading failures and dismissals by attempting to reload.

```kotlin
class AppOpenAdManager(application: Application) : AppOpenAdLoadListener {

    private val appOpenAdLoader = AppOpenAdLoader(application)
    private val adRequest = AdRequest.Builder("demo-appopenad-yandex").build()
    private var appOpenAd: AppOpenAd? = null
    private var activityRef: WeakReference<Activity>? = null
    private var loading = AtomicBoolean(false)

    init {
        // Watch for app coming to foreground
        ProcessLifecycleOwner.get().lifecycle.addObserver(
            DefaultProcessLifecycleObserver(onProcessCameForeground = ::showIfReady)
        )
        // Track which activity is current
        application.registerActivityLifecycleCallbacks(object : DefaultActivityLifecycleCallbacks {
            override fun onActivityStarted(activity: Activity) {
                activityRef = WeakReference(activity)
            }
        })
    }

    fun preload() = loadAppOpenAd()

    override fun onAdLoaded(appOpenAd: AppOpenAd) {
        this.appOpenAd = appOpenAd
        loading.set(false)
    }

    override fun onAdFailedToLoad(error: AdRequestError) {
        loading.set(false)
        Log.e("Ads", "AppOpen failed: ${error.description}")
    }

    private fun showIfReady() {
        activityRef?.get()?.let { activity ->
            val ad = appOpenAd
            if (ad != null) {
                ad.setAdEventListener(object : AppOpenAdEventListener {
                    override fun onAdShown() {}
                    override fun onAdFailedToShow(e: AdError) { loadAppOpenAd() }
                    override fun onAdDismissed() {
                        appOpenAd?.setAdEventListener(null)
                        appOpenAd = null
                        loadAppOpenAd()
                    }
                    override fun onAdClicked() {}
                    override fun onAdImpression(data: ImpressionData?) {}
                })
                ad.show(activity)
            } else {
                loadAppOpenAd()
            }
        }
    }

    private fun loadAppOpenAd() {
        if (loading.compareAndSet(false, true)) {
            appOpenAdLoader.loadAd(adRequest, this)
        }
    }
}

// In Application.onCreate:
// YandexAds.initialize(this) { AppOpenAdManager(this).preload() }
```

--------------------------------

### Implement Bidding Provider for Header Bidding

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Implement the `MediationBiddingProvider` interface to obtain bidding tokens for header bidding. Use `BidderTokenLoader` to request tokens for specific ad formats like interstitial or banner ads.

```kotlin
class MyBiddingProvider : MediationBiddingProvider {
    override fun loadBidderToken(context: Context, params: MediationParameters,
                                 callback: MediationBiddingListener) {
        val tokenRequest = BidderTokenRequest.interstitial() // or .banner(size), .rewarded(), etc.
        BidderTokenLoader(context).loadBidderToken(tokenRequest, object : BidderTokenLoadListener {
            override fun onBidderTokenLoaded(token: String) = callback.onTokenLoaded(token)
            override fun onBidderTokenFailedToLoad(reason: String) = callback.onTokenFailedToLoad()
        })
    }
}
```

--------------------------------

### Configure Privacy Policies Globally

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Set GDPR, COPPA, and location consent globally using static methods on `YandexAds`. These settings persist until changed and should be configured before `YandexAds.initialize()`.

```kotlin
// GDPR — set when user has explicitly granted ad personalization consent
YandexAds.setUserConsent(true)

// COPPA — set to true for child-directed apps (disables personalized ads)
YandexAds.setAgeRestricted(false)

// Location targeting — set to true only if the app has ACCESS_FINE_LOCATION permission
// and the user has consented to location use
YandexAds.setLocationTracking(false)

// Query current SDK version string
val version: String = YandexAds.libraryVersion // e.g. "8.0.0"
```

--------------------------------

### Create Bidder Token Request Configuration

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/ThirdPartyMediationAdapterTemplate/README.md

Generate a BidderTokenRequestConfiguration based on the ad type. Banner configurations require a bannerAdSize.

```kotlin
fun createBidderTokenRequestConfiguration(): BidderTokenRequestConfiguration {
    return when (adType) {
        AdType.BANNER -> BidderTokenRequestConfiguration.banner(bannerAdSize)
        AdType.INTERSTITIAL -> BidderTokenRequestConfiguration.interstitial()
        AdType.REWARDED -> BidderTokenRequestConfiguration.rewarded()
        AdType.NATIVE -> BidderTokenRequestConfiguration.native()
        AdType.APP_OPEN_AD -> BidderTokenRequestConfiguration.appOpenAd()
    }
}
```

--------------------------------

### Bulk Native Load

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

Bulk native ad loading in v8 uses `loader.loadAds(request, count, listener)`, replacing the v7 method `loader.loadAds(config, count)` and requiring a listener.

```java
loader.setNativeBulkAdLoadListener(listener)
loader.loadAds(config, count)
```

```java
loader.loadAds(request, count, listener)
```

--------------------------------

### Configure Project Repositories for Mediation

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/README.md

Add these Maven repositories to your project's build.gradle file to ensure all mediation libraries are accessible.

```gradle
allprojects {
    repositories {

        ... 

        // IronSource
        maven { url 'https://android-sdk.is.com/' }

        // Pangle
        maven { url 'https://artifact.bytedance.com/repository/pangle' }

        // Tapjoy
        maven { url 'https://sdk.tapjoy.com/' }

        // Mintegral
        maven { url 'https://dl-maven-android.mintegral.com/repository/mbridge_android_sdk_oversea'}

        // Chartboost
        maven { url 'https://cboost.jfrog.io/artifactory/chartboost-ads/' }

        // AppNext
        maven { url 'https://dl.appnext.com/' }
    }
}
```

--------------------------------

### Instream Ad Loading in SDK 8

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

In SDK 8, the `loadInstreamAd` method now accepts the listener as the second parameter, simplifying the loading process compared to SDK 7.x.

```java
loader.loadInstreamAd(request, listener);
```

--------------------------------

### Implement Base Mediation Adapter

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Implement the `MediationBaseAdapter` interface to provide core adapter functionality. This includes retrieving SDK version, updating privacy policies, and initializing the Yandex Ads SDK with adapter identity.

```kotlin
class YandexBaseAdapter : MediationBaseAdapter {
    override fun getSDKVersionInfo(): String = YandexAds.libraryVersion

    override fun updatePrivacyPolicies(params: MediationParameters) {
        YandexAds.setUserConsent(params.hasUserConsent())
        YandexAds.setAgeRestricted(params.isAgeRestrictedUser())
        YandexAds.setLocationTracking(params.hasLocationConsent())
    }

    override fun initialize(context: Context, params: MediationParameters, onDone: () -> Unit) {
        val identity = AdapterIdentity(
            adapterNetworkName    = params.getAdapterNetworkName(),    // e.g. "myadnetwork"
            adapterVersion        = params.getAdapterVersion(),        // e.g. "8.0.0.1"
            adapterNetworkVersion = params.getAdapterNetworkSdkVersion() // e.g. "3.5.0"
        )
        YandexAds.setAdapterIdentity(identity)
        YandexAds.initialize(context) { onDone() }
    }
}
```

--------------------------------

### Instream Ad Break Prepare in SDK 8

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

The `prepare` method for `InstreamAdBreak` in SDK 8 is now optional regarding the player parameter, allowing for preparation without explicitly passing a player instance.

```java
adBreak.prepare()
```

```java
adBreak.prepare(player)
```

--------------------------------

### Privacy Policies and SDK Version

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Globally configures privacy settings such as user consent for GDPR, age restrictions for COPPA, and location tracking. Also provides a way to query the current SDK version.

```APIDOC
## Privacy Policies — `YandexAds` static methods

GDPR, COPPA, and location consent are set globally and persist until changed. They should be configured before `YandexAds.initialize()` and updated whenever user preferences change.

```kotlin
// GDPR — set when user has explicitly granted ad personalization consent
YandexAds.setUserConsent(true)

// COPPA — set to true for child-directed apps (disables personalized ads)
YandexAds.setAgeRestricted(false)

// Location targeting — set to true only if the app has ACCESS_FINE_LOCATION permission
// and the user has consented to location use
YandexAds.setLocationTracking(false)

// Query current SDK version string
val version: String = YandexAds.libraryVersion // e.g. "8.0.0"
```
```

--------------------------------

### Extract AdTargeting from AdRequest.Builder

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

For AdTargeting parameters like age, gender, and location, use the new `AdTargeting.Builder`. Move existing `.setAge()`, `.setGender()`, and `.setLocation()` calls to the `AdTargeting.Builder` and then set the built `AdTargeting` object on the `AdRequest.Builder`.

```java
AdRequest.Builder().setAge(25).setGender(Gender.MALE)
AdRequest.Builder(id).setTargeting(AdTargeting.Builder().setAge(25).setGender(Gender.MALE).build())
```

--------------------------------

### Implement Interstitial Mediation Adapter

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Implement the `MediationInterstitialAdapter` interface for interstitial ads. This involves loading ads using `InterstitialAdLoader`, handling ad events, and managing the ad lifecycle. Ensure to delegate initialization and privacy policy updates to the base adapter.

```kotlin
class MyNetworkInterstitialAdapter : MediationInterstitialAdapter {
    private val base = YandexBaseAdapter()
    private var loader: InterstitialAdLoader? = null
    private var ad: InterstitialAd? = null

    override fun loadInterstitialAd(context: Context, params: MediationParameters,
                                    callback: MediationInterstitialListener) {
        loader = loader ?: InterstitialAdLoader(context)
        val request = AdRequest.Builder(params.getAdUnitId())
            .setBiddingData(params.getBidderToken())
            .build()
        loader?.loadAd(request, object : InterstitialAdLoadListener {
            override fun onAdLoaded(interstitialAd: InterstitialAd) {
                ad = interstitialAd.also { it.setAdEventListener(eventListenerOf(callback)) }
                callback.onAdLoaded()
            }
            override fun onAdFailedToLoad(error: AdRequestError) = callback.onAdFailedToLoad()
        })
    }

    override fun showInterstitialAd(activity: Activity) { ad?.show(activity) }
    override fun destroy() { ad?.setAdEventListener(null); ad = null; loader = null }
    override fun getSDKVersionInfo() = base.getSDKVersionInfo()
    override fun updatePrivacyPolicies(params: MediationParameters) = base.updatePrivacyPolicies(params)
    override fun initialize(ctx: Context, params: MediationParameters, onDone: () -> Unit) =
        base.initialize(ctx, params, onDone)
}
```

--------------------------------

### Load and Bind Native Ad using NativeBannerView

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Utilize `NativeBannerView` for a simplified native ad integration. This pre-built template view automatically renders all native assets after calling `bindNativeAd`.

```kotlin
// In layout XML:
// <com.yandex.mobile.ads.nativeads.template.NativeBannerView
//     android:id="@+id/native_banner"
//     android:layout_width="match_parent"
//     android:layout_height="wrap_content" />

class NativeTemplateActivity : AppCompatActivity() {

    private var nativeAdLoader: NativeAdLoader? = null
    private lateinit var nativeBanner: NativeBannerView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_native_template)
        nativeBanner = findViewById(R.id.native_banner)
        loadNativeAd()
    }

    private fun loadNativeAd() {
        nativeAdLoader?.cancelLoading()
        nativeAdLoader = NativeAdLoader(this)
        nativeBanner.release()

        val options = NativeAdOptions.Builder()
            .setShouldLoadImagesAutomatically(true)
            .build()
        val request = AdRequest.Builder("demo-native-content-yandex").build()

        nativeAdLoader?.loadAd(request, options, object : NativeAdLoadListener {
            override fun onAdLoaded(nativeAd: NativeAd) {
                nativeAd.setNativeAdEventListener(object : NativeAdEventListener {
                    override fun onAdClicked() {}
                    override fun onImpression(data: ImpressionData?) {}
                })
                nativeBanner.bindNativeAd(nativeAd) // renders immediately
            }
            override fun onAdFailedToLoad(error: AdRequestError) {
                Log.e("Ads", "Error: ${error.description}")
            }
        })
    }

    override fun onDestroy() {
        nativeAdLoader?.cancelLoading()
        nativeBanner.release()
        super.onDestroy()
    }
}
```

--------------------------------

### Instream Initialization

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

The method for preloading ad groups in instream ads has been renamed from `MobileInstream.setAdGroupPreloading(...)` to `YandexInstreamAds.setAdGroupPreloading(...)`.

```java
MobileInstream.setAdGroupPreloading(...)
```

```java
YandexInstreamAds.setAdGroupPreloading(...)
```

--------------------------------

### Load and Show Interstitial Ad

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Loads and displays full-screen interstitial ads. It's recommended to reuse the `InterstitialAdLoader` instance for better performance. Remember to clear the event listener and set `interstitialAd` to null after dismissal before reloading.

```kotlin
class InterstitialActivity : AppCompatActivity(), InterstitialAdLoadListener {

    // Reuse loader across multiple load calls
    private var interstitialAdLoader: InterstitialAdLoader? = null
    private var interstitialAd: InterstitialAd? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_interstitial)

        interstitialAdLoader = InterstitialAdLoader(this)

        findViewById<Button>(R.id.load_btn).setOnClickListener { loadAd() }
        findViewById<Button>(R.id.show_btn).setOnClickListener { showAd() }

        loadAd()
    }

    private fun loadAd() {
        val request = AdRequest.Builder("demo-interstitial-yandex").build()
        interstitialAdLoader?.loadAd(request, this)
    }

    // InterstitialAdLoadListener
    override fun onAdLoaded(ad: InterstitialAd) {
        interstitialAd = ad
        Log.d("Ads", "Interstitial loaded")
    }

    override fun onAdFailedToLoad(error: AdRequestError) {
        Log.e("Ads", "Load failed [${error.code}]: ${error.description}")
    }

    private fun showAd() {
        interstitialAd?.apply {
            setAdEventListener(object : InterstitialAdEventListener {
                override fun onAdShown() { Log.d("Ads", "Shown") }
                override fun onAdFailedToShow(e: AdError) { Log.e("Ads", "Show error: $e") }
                override fun onAdDismissed() {
                    interstitialAd?.setAdEventListener(null)
                    interstitialAd = null
                    loadAd() // Preload next ad
                }
                override fun onAdClicked() {}
                override fun onAdImpression(data: ImpressionData?) {}
            })
            show(this@InterstitialActivity)
        }
    }

    override fun onDestroy() {
        interstitialAdLoader?.cancelLoading()
        interstitialAd?.setAdEventListener(null)
        super.onDestroy()
    }
}
```

--------------------------------

### Banner Size (Sticky)

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

The method for calculating sticky banner ad size has been renamed from `BannerAdSize.stickySize(context, width)` to `BannerAdSize.sticky(context, width)`.

```java
BannerAdSize.stickySize(context, width)
```

```java
BannerAdSize.sticky(context, width)
```

--------------------------------

### Native Load

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

Similar to interstitials, native ad loading in v8 uses `loader.loadAd(request, listener)`, replacing the v7 method `loader.loadAd(config)` and requiring a listener.

```java
loader.setNativeAdLoadListener(listener)
loader.loadAd(config)
```

```java
loader.loadAd(request, listener)
```

--------------------------------

### Instream Player View Binding

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

Implement the `bindPlayerView` method in `InstreamAdPlayer` to add your player view to the provided container with MATCH_PARENT layout parameters.

```java
override fun bindPlayerView(container: FrameLayout)
```

--------------------------------

### Replace NativeBannerView with NativeAdBannerView in XML

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

Update the XML layout to use the new NativeAdBannerView. Ensure to use the partner's app package and retain existing IDs and layout parameters. Remove the deprecated app:appearance attribute.

```xml
<com.yandex.ads.nativead.NativeAdBannerView
    android:id="@+id/native_ad_container"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:minHeight="300dp" />
```

--------------------------------

### Instream Ad Binder Player in SDK 8

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

The `InstreamAdBinder` constructor in SDK 8 allows the player parameter to be optional (null), providing flexibility when the SDK's default player behavior is acceptable.

```java
InstreamAdBinder(context, ad, null, videoPlayer)
```

--------------------------------

### Load and Display Feed Ads in RecyclerView

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Use `FeedAdAdapter` to insert ad cards into a `RecyclerView`. Call `preloadAd()` early to ensure ads are ready when the user scrolls. This adapter is compatible with `ConcatAdapter` for mixing ads with app content.

```kotlin
class FeedActivity : AppCompatActivity() {

    private var feedAdAdapter: FeedAdAdapter? = null
    private lateinit var feedAd: FeedAd

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_feed)

        val screenWidth = resources.displayMetrics.widthPixels
        val cardWidth = screenWidth - 2 * 48 // 48dp margins converted to px

        val appearance = FeedAdAppearance(
            cardWidth = cardWidth,
            cardCornerRadius = 14.0
        )
        val request = AdRequest.Builder("demo-feed-yandex").build()
        feedAd = FeedAd.Builder(this, request, appearance).build()
        feedAd.loadListener = object : FeedAdLoadListener {
            override fun onAdLoaded() { showFeed() }
            override fun onAdFailedToLoad(error: AdRequestError) {
                Log.e("Ads", "Feed error: $error")
            }
        }
        feedAd.preloadAd()
    }

    private fun showFeed() {
        val recyclerView = findViewById<RecyclerView>(R.id.recycler_view)
        feedAdAdapter = FeedAdAdapter(feedAd).apply {
            eventListener = object : FeedAdEventListener {
                override fun onAdClicked() { Log.d("Ads", "Feed clicked") }
                override fun onImpression(data: ImpressionData?) {}
            }
        }

        // Optionally mix with app content using ConcatAdapter
        val contentAdapter = MyContentAdapter(items)
        recyclerView.layoutManager = LinearLayoutManager(this)
        recyclerView.adapter = ConcatAdapter(contentAdapter, feedAdAdapter)
    }
}
```

--------------------------------

### Banner Size (Inline)

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

The method for calculating inline banner ad size has been renamed from `BannerAdSize.inlineSize(context, width, maxHeight)` to `BannerAdSize.inline(context, width, maxHeight)`.

```java
BannerAdSize.inlineSize(context, width, maxHeight)
```

```java
BannerAdSize.inline(context, width, maxHeight)
```

--------------------------------

### Load and Bind Instream Video Ads

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Use `InstreamAdLoader` and `InstreamAdBinder` to play instream ads within a video player. `InstreamAdBinder` manages ad-break scheduling based on VMAP configuration. Ensure to unbind and release players in `onDestroy`.

```kotlin
class InstreamActivity : AppCompatActivity() {

    private var instreamAdLoader: InstreamAdLoader? = null
    private var instreamAdBinder: InstreamAdBinder? = null
    private var contentVideoPlayer: ContentVideoPlayer? = null
    private var instreamAdPlayer: SampleInstreamAdPlayer? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_instream)

        val playerView = findViewById<PlayerView>(R.id.player_view)
        contentVideoPlayer = ContentVideoPlayer("https://example.com/content.m3u8", playerView)
        instreamAdPlayer = SampleInstreamAdPlayer(playerView)

        instreamAdLoader = InstreamAdLoader(this)
        val config = InstreamAdRequest.Builder("demo-instream-vmap-yandex").build()

        instreamAdLoader?.loadAd(config, object : InstreamAdLoadListener {
            override fun onInstreamAdLoaded(ad: InstreamAd) {
                instreamAdBinder = InstreamAdBinder(
                    this@InstreamActivity,
                    ad,
                    checkNotNull(contentVideoPlayer),
                    checkNotNull(instreamAdPlayer)
                ).apply {
                    setInstreamAdListener(object : InstreamAdListener {
                        override fun onInstreamAdCompleted() { Log.d("Ads", "Instream complete") }
                        override fun onInstreamAdPrepared() { Log.d("Ads", "Instream prepared") }
                        override fun onError(error: String) { Log.e("Ads", "Error: $error") }
                    })
                    bind(findViewById(R.id.instream_ad_view))
                }
            }
            override fun onInstreamAdFailedToLoad(error: InstreamAdRequestError) {
                Log.e("Ads", "Instream load failed: ${error.description}")
            }
        })
    }

    override fun onDestroy() {
        instreamAdBinder?.unbind()
        instreamAdBinder?.invalidateAdPlayer()
        instreamAdBinder?.invalidateVideoPlayer()
        contentVideoPlayer?.release()
        instreamAdPlayer?.release()
        super.onDestroy()
    }
}
```

--------------------------------

### Compose Banner Ad Integration

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Use `rememberBannerAdState` and `Banner` composable for Jetpack Compose banner ads. Load ads using `LaunchedEffect` and manage ad lifecycle tied to composition.

```kotlin
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import com.yandex.mobile.ads.common.AdRequest
import com.yandex.mobile.ads.compose.banner.Banner
import com.yandex.mobile.ads.compose.banner.BannerSize
import com.yandex.mobile.ads.compose.banner.rememberBannerAdState
import com.yandex.mobile.ads.common.ImpressionData
import com.yandex.mobile.ads.banner.BannerAdEventListener

@Composable
fun BannerAdScreen() {
    var logs by remember { mutableStateOf("") }

    val bannerState = rememberBannerAdState(
        adSize = BannerSize.Inline(width = 320.dp, maxHeight = 250.dp),
        events = BannerEvents(
            onAdLoaded = { _ -> logs += "Loaded\n" },
            onAdFailedToLoad = { error -> logs += "Failed: ${error.description}\n" },
            onAdClicked = { logs += "Clicked\n" },
            onImpression = { logs += "Impression\n" },
        ),
    )

    // Load ad when adUnitId is available
    LaunchedEffect(Unit) {
        bannerState.loadAd(AdRequest.Builder("demo-banner-yandex").build())
    }

    Column(modifier = Modifier.fillMaxSize().padding(16.dp)) {
        Text(text = logs, fontSize = 12.sp)
        Spacer(modifier = Modifier.height(8.dp))
        Banner(
            state = bannerState,
            modifier = Modifier.fillMaxWidth()
        )
    }
}
```

--------------------------------

### Interstitial Load

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

The interstitial ad loading process in v8 uses `loader.loadAd(request, listener)`, which replaces the v7 method `loader.loadAd(config)` and requires a listener to be passed.

```java
loader.setAdLoadListener(listener)
loader.loadAd(config)
```

```java
loader.loadAd(request, listener)
```

--------------------------------

### Instream Load

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

The instream ad loading method in v8 is `loader.loadInstreamAd(request, listener)`, which replaces the v7 method `loader.loadInstreamAd(request)` and now includes a listener parameter.

```java
loader.setInstreamAdLoadListener(listener)
loader.loadInstreamAd(request)
```

```java
loader.loadInstreamAd(request, listener)
```

--------------------------------

### Add YandexMobileAds SDK with Mediation

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/README.md

Use this dependency in your app module's build.gradle if you need to integrate with mediation platforms.

```gradle
implementation 'com.yandex.android:mobileads-mediation:8.0.0.0'
```

--------------------------------

### Load Bidder Token

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/ThirdPartyMediationAdapterTemplate/README.md

Obtain a bidder token for S2S bidding using BidderTokenLoader. A new token is required for each ad request.

```kotlin
val loadListener = object : BidderTokenLoadListener {
    override fun onBidderTokenLoaded(token: String) = callback.onTokenLoaded(token)
    override fun onBidderTokenFailedToLoad(msg: String) = callback.onTokenFailedToLoad()
}

// Create an instance of BidderTokenLoader
val bidderTokenLoader = BidderTokenLoader(context)
bidderTokenLoader.loadBidderToken(tokenRequest, loadListener)
```

--------------------------------

### Disable Automatic SDK Initialization

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/ThirdPartyMediationAdapterTemplate/README.md

To manually control SDK initialization, disable the automatic process by adding a meta-data tag to your AndroidManifest.xml.

```xml
<manifest>
    <application>
        <!-- Disable automatic sdk initialization.  -->
        <meta-data
            android:name="com.yandex.mobile.ads.AUTOMATIC_SDK_INITIALIZATION"
            android:value="false" />
    </application>
</manifest>
```

--------------------------------

### Compose Banner Ad Integration

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Integrates a banner ad using Jetpack Compose. It utilizes `rememberBannerAdState` to manage the ad's lifecycle and the `Banner` composable for rendering. Ad events like loading, failure, clicks, and impressions are logged.

```APIDOC
## Compose Banner — `Banner` composable / `rememberBannerAdState`

The `mobileads-compose` artifact provides first-class Jetpack Compose support. Use `rememberBannerAdState` to manage ad lifecycle tied to composition, and the `Banner` composable to render it.

```kotlin
@Composable
fun BannerAdScreen() {
    var logs by remember { mutableStateOf("") }

    val bannerState = rememberBannerAdState(
        adSize = BannerSize.Inline(width = 320.dp, maxHeight = 250.dp),
        events = BannerEvents(
            onAdLoaded = { _ -> logs += "Loaded\n" },
            onAdFailedToLoad = { error -> logs += "Failed: ${error.description}\n" },
            onAdClicked = { logs += "Clicked\n" },
            onImpression = { logs += "Impression\n" },
        ),
    )

    // Load ad when adUnitId is available
    LaunchedEffect(Unit) {
        bannerState.loadAd(AdRequest.Builder("demo-banner-yandex").build())
    }

    Column(modifier = Modifier.fillMaxSize().padding(16.dp)) {
        Text(text = logs, fontSize = 12.sp)
        Spacer(modifier = Modifier.height(8.dp))
        Banner(
            state = bannerState,
            modifier = Modifier.fillMaxWidth()
        )
    }
}
```
```

--------------------------------

### Update Kotlin/Java Code for Native Ads

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

Modify the code to use `bindNativeAd` instead of `setAd` for binding native ads. Ensure `release()` is called before new ad loads and in the `onDestroy()` method to prevent memory leaks.

```kotlin
nativeBannerView.bindNativeAd(nativeAd)
```

```kotlin
nativeBannerView.release()
```

--------------------------------

### Load and Display Inline Banner Ad

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Embeds an inline banner ad within scrollable content. The SDK automatically adjusts the ad's height to fit within a specified maximum. Ensure the ad view is added to a suitable layout container.

```kotlin
class InlineBannerActivity : AppCompatActivity() {

    private var bannerAd: BannerAdView? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_inline_banner)

        val root = findViewById<ConstraintLayout>(R.id.root)
        root.viewTreeObserver.addOnGlobalLayoutListener(object : 
            ViewTreeObserver.OnGlobalLayoutListener {
            override fun onGlobalLayout() {
                root.viewTreeObserver.removeOnGlobalLayoutListener(this)
                val adWidth = (root.width / resources.displayMetrics.density).roundToInt()
                val screenHeight = (resources.displayMetrics.run { heightPixels / density }).roundToInt()
                val maxHeight = screenHeight / 3

                val adSize = BannerAdSize.inline(this@InlineBannerActivity, adWidth, maxHeight)
                bannerAd = BannerAdView(this@InlineBannerActivity).apply {
                    setAdSize(adSize)
                    setBannerAdEventListener(object : BannerAdEventListener {
                        override fun onAdLoaded() { Log.d("Ads", "Inline banner loaded") }
                        override fun onAdFailedToLoad(error: AdRequestError) {
                            Log.e("Ads", "Error ${error.code}: ${error.description}")
                        }
                        override fun onAdClicked() {}
                        override fun onImpression(data: ImpressionData?) {}
                    })
                    loadAd(AdRequest.Builder("demo-banner-yandex").build())
                }
                root.addView(bannerAd, ConstraintLayout.LayoutParams(
                    ConstraintLayout.LayoutParams.MATCH_PARENT,
                    ConstraintLayout.LayoutParams.WRAP_CONTENT
                ))
            }
        })
    }

    override fun onDestroy() {
        bannerAd?.destroy()
        super.onDestroy()
    }
}
```

--------------------------------

### Compose Interstitial Ad Integration

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Integrates a full-screen interstitial ad using Jetpack Compose. It uses `rememberInterstitialAdLoader` to load ads asynchronously and `InterstitialAd` to display them. Event listeners are set for ad lifecycle events.

```APIDOC
## Compose Interstitial — `rememberInterstitialAdLoader`

For full-screen ad formats in Compose, use the coroutine-based `rememberInterstitialAdLoader` which suspends until the load result is available, enabling a seamless integration with `LaunchedEffect` or button `onClick` scopes.

```kotlin
@Composable
fun InterstitialAdScreen() {
    val context = LocalContext.current
    val scope = rememberCoroutineScope()
    var loadedAd by remember { mutableStateOf<InterstitialAd?>(null) }
    var status by remember { mutableStateOf("") }

    val loader = rememberInterstitialAdLoader()

    Column(modifier = Modifier.fillMaxSize().padding(16.dp)) {
        Button(onClick = {
            scope.launch {
                status = "Loading…"
                when (val result = loader.loadAd(AdRequest.Builder("demo-interstitial-yandex").build())) {
                    is InterstitialAdLoadResult.Success -> {
                        loadedAd = result.ad
                        status = "Ready"
                    }
                    is InterstitialAdLoadResult.Failure -> {
                        status = "Failed: ${result.error.description}"
                    }
                }
            }
        }) { Text("Load") }

        Button(
            enabled = loadedAd != null,
            onClick = {
                loadedAd?.apply {
                    setAdEventListener(object : InterstitialAdEventListener {
                        override fun onAdShown() {}
                        override fun onAdFailedToShow(e: AdError) {}
                        override fun onAdDismissed() { loadedAd = null }
                        override fun onAdClicked() {}
                        override fun onAdImpression(data: ImpressionData?) {}
                    })
                    show(context as Activity)
                }
            }
        ) { Text("Show") }

        Text(status)
    }
}
```
```

--------------------------------

### Instream Player Supported MIME Types

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

Implement the `supportedMimeTypes` property in `InstreamAdPlayer` to return a list of supported MIME types, using constants from `InstreamAdMimeTypes` or fallback string literals.

```java
override val supportedMimeTypes: List<String>
```

--------------------------------

### Compose Interstitial Ad Integration

Source: https://context7.com/yandexmobile/yandex-ads-sdk-android/llms.txt

Use `rememberInterstitialAdLoader` for full-screen ads in Compose. This function suspends until the load result is available, integrating seamlessly with `LaunchedEffect` or button `onClick` scopes.

```kotlin
import android.app.Activity
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Button
import androidx.compose.material3.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.unit.dp
import com.yandex.mobile.ads.common.AdRequest
import com.yandex.mobile.ads.common.AdError
import com.yandex.mobile.ads.common.ImpressionData
import com.yandex.mobile.ads.interstitial.InterstitialAd
import com.yandex.mobile.ads.interstitial.InterstitialAdEventListener
import com.yandex.mobile.ads.interstitial.InterstitialAdLoadResult
import com.yandex.mobile.ads.interstitial.rememberInterstitialAdLoader

@Composable
fun InterstitialAdScreen() {
    val context = LocalContext.current
    val scope = rememberCoroutineScope()
    var loadedAd by remember { mutableStateOf<InterstitialAd?>(null) }
    var status by remember { mutableStateOf("") }

    val loader = rememberInterstitialAdLoader()

    Column(modifier = Modifier.fillMaxSize().padding(16.dp)) {
        Button(onClick = {
            scope.launch {
                status = "Loading…"
                when (val result = loader.loadAd(AdRequest.Builder("demo-interstitial-yandex").build())) {
                    is InterstitialAdLoadResult.Success -> {
                        loadedAd = result.ad
                        status = "Ready"
                    }
                    is InterstitialAdLoadResult.Failure -> {
                        status = "Failed: ${result.error.description}"
                    }
                }
            }
        }) { Text("Load") }

        Button(
            enabled = loadedAd != null,
            onClick = {
                loadedAd?.apply {
                    setAdEventListener(object : InterstitialAdEventListener {
                        override fun onAdShown() {}
                        override fun onAdFailedToShow(e: AdError) {}
                        override fun onAdDismissed() { loadedAd = null }
                        override fun onAdClicked() {}
                        override fun onAdImpression(data: ImpressionData?) {}
                    })
                    show(context as Activity)
                }
            }
        ) { Text("Show") }

        Text(status)
    }
}
```

--------------------------------

### Native Binding

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

Native ad binding in v8 uses a `when` statement to handle `AdBindingResult.Failure` and `AdBindingResult.Success`, replacing the `try-catch` block for `NativeAdException` in v7.

```kotlin
try { ad.bindNativeAd(binder) } catch (e: NativeAdException)
```

```kotlin
when (ad.bindNativeAd(binder)) { is AdBindingResult.Failure -> ..., is AdBindingResult.Success -> ... }
```

--------------------------------

### Slider Load

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/YandexMobileAdsExample/skills/migrate-yandex-ads-sdk-from-7-to-8/SKILL.md

Slider ad loading in v8 can use either `loader.loadAd(request, listener)` or `loader.loadAd(request, options, listener)`, replacing the v7 method `loader.loadSlider(config)` and offering more flexibility.

```java
loader.setSliderAdLoadListener(listener)
loader.loadSlider(config)
```

```java
loader.loadAd(request, listener) or
loader.loadAd(request, options, listener)
```

--------------------------------

### Add Yandex Mobile Ads SDK Dependency

Source: https://github.com/yandexmobile/yandex-ads-sdk-android/blob/master/ThirdPartyMediationAdapterTemplate/README.md

Include the Yandex Mobile Ads SDK in your app's build file. Ensure you use the latest version available.

```kotlin
dependencies {
    implementation("com.yandex.android:mobileads:$YANDEX_SDK_VERSION")
}
```