Rewarded ads

Rewarded ads are a full-screen ad format where users get bonuses or other rewards (for example, in-game coins, retries, access to premium features, and so on) for watching ads.

Note

It's the user who decides whether to watch the ad or skip it, receiving a reward only if they watch it to the end.

Note

Examples showing how all the format types work are available in the demo project.

Example of creating a rewarded ad using a ready-to-use XML file

class RewardedAdActivity : AppCompatActivity(), RewardedAdEventListener {

    private var rewardedAdLoader: RewardedAdLoader? = null
    private var rewardedAd: RewardedAd? = null
    private val adUnitId = "demo-rewarded-yandex"
    private lateinit var binding: ActivityRewardedAdBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityRewardedAdBinding.inflate(layoutInflater)
        setContentView(binding.root)

        binding.btnLoadBanner.setOnClickListener {
            loadRewardedAd()
        }
        binding.btnShowBanner.setOnClickListener {
            showRewardedAd()
        }

        rewardedAdLoader = RewardedAdLoader(this).apply {
            setAdLoadListener(object : RewardedAdLoadListener {
                override fun onAdLoaded(ad: RewardedAd) {
                    rewardedAd = ad;
                    enableShowAdButton()
                }

                override fun onAdFailedToLoad(adRequestError: AdRequestError) {
                    disabeShowAdButton()
                }
            })
        }
    }

    private fun loadRewardedAd() {
        disabeShowAdButton()
        rewardedAdLoader?.loadAd(createAdRequestConfiguration())
    }

    private fun createAdRequestConfiguration(): AdRequestConfiguration =
        AdRequestConfiguration.Builder(adUnitId).build()

    private fun showRewardedAd() {
        disabeShowAdButton()
        rewardedAd?.apply {
            setAdEventListener(this@RewardedAdActivity)
            show(this@RewardedAdActivity)
        }
    }

    private fun destroyRewardedAd() {
        // don't forget to clean up event listener to null?
        rewardedAd?.setAdEventListener(null)
        rewardedAd = null
    }

    override fun onDestroy() {
        // Set listener to null to avoid memory leaks
        rewardedAdLoader?.setAdLoadListener(null)
        rewardedAdLoader = null
        destroyRewardedAd()
        super.onDestroy()
    }

    private fun enableShowAdButton() {
        binding.btnShowBanner.isEnabled = true
    }

    private fun disabeShowAdButton() {
        binding.btnShowBanner.isEnabled = false
    }

    override fun onAdClicked() {}
    override fun onAdFailedToShow(adError: AdError) {}
    override fun onAdImpression(impressionData: ImpressionData?) {}
    override fun onAdShown() {}
    override fun onRewarded(reward: Reward) {}
    override fun onAdDismissed() {
        destroyRewardedAd()
        // Now you can preload the next rewarded ad.
        loadRewardedAd()
    }
}

<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/coordinatorLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".RewardedAdActivity">

    <Button
        android:id="@+id/btnLoadBanner"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Load Banner"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintBottom_toBottomOf="parent" />

    <Button
        android:id="@+id/btnShowBanner"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Show Banner"
        app:layout_constraintTop_toBottomOf="@id/btnLoadBanner"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        android:layout_marginTop="16dp" />

</androidx.constraintlayout.widget.ConstraintLayout>

Example of creating a rewarded ad using a programmatically generated Activity

class RewardedAdActivity : AppCompatActivity(), RewardedAdEventListener,
    RewardedAdLoadListener {

    private val adUnitId = "demo-rewarded-yandex" // Use R-M-XXXXXX-Y or demo-block (look for the description below)
    private var rewardedAdLoader: RewardedAdLoader? = null
    private var rewardedAd: RewardedAd? = null

    private lateinit var loadButton: Button
    private lateinit var showButton: Button
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        val rootLayout = ConstraintLayout(this).apply {
            layoutParams = LayoutParams(MATCH_PARENT, MATCH_PARENT)
        }

        loadButton = Button(this).apply {
            text = "Load Rewarded Ad"
            id = View.generateViewId()
        }

        showButton = Button(this).apply {
            text = "Show Rewarded Ad"
            id = View.generateViewId()
            isEnabled = false
        }

        rootLayout.addView(loadButton, LayoutParams(WRAP_CONTENT, WRAP_CONTENT).apply {
            topToTop = PARENT_ID
            bottomToBottom = PARENT_ID
            startToStart = PARENT_ID
            endToEnd = PARENT_ID
        })

        rootLayout.addView(showButton, LayoutParams(WRAP_CONTENT, WRAP_CONTENT).apply {
            topToBottom = loadButton.id
            startToStart = PARENT_ID
            endToEnd = PARENT_ID
            topMargin = 24
        })

        setContentView(rootLayout)

        rewardedAdLoader = RewardedAdLoader(this).apply {
            setAdLoadListener(this@RewardedAdActivity)
        }
        loadButton.setOnClickListener { loadRewardedAd() }
        showButton.setOnClickListener { showRewardedAd() }
    }

    override fun onAdFailedToLoad(error: AdRequestError) {}
    override fun onAdLoaded(ad: RewardedAd) {
        rewardedAd = ad
        enableShowButton()
        println("Rewarded ad loaded!")
    }

    private fun loadRewardedAd() {
        disableShowButton()
        val config = AdRequestConfiguration.Builder(adUnitId).build()
        rewardedAdLoader?.loadAd(config)
    }

    private fun showRewardedAd() {
        disableShowButton()
        rewardedAd?.apply {
            setAdEventListener(this@RewardedAdActivity)
            show(this@RewardedAdActivity)
        }
    }

    private fun destroyRewardedAd() {
        rewardedAd?.setAdEventListener(null)
        rewardedAd = null
    }

    private fun enableShowButton() {
        showButton.isEnabled = true
    }

    private fun disableShowButton() {
        showButton.isEnabled = false
    }

    override fun onDestroy() {
        rewardedAdLoader?.setAdLoadListener(null)
        rewardedAdLoader = null
        destroyRewardedAd()
        super.onDestroy()
    }

    override fun onAdShown() {}
    override fun onAdFailedToShow(adError: AdError) {}
    override fun onAdDismissed() {
        println("🚪 Ad dismissed")
        destroyRewardedAd()
        loadRewardedAd() // Preload new ad
    }
    override fun onRewarded(reward: Reward) {
        println("🏆 Reward granted: ${reward.amount} ${reward.type}")
    }
    override fun onAdClicked() {}
    override fun onAdImpression(data: ImpressionData?) {}
}

public class RewardedAdActivity extends AppCompatActivity
        implements RewardedAdEventListener, RewardedAdLoadListener {

    private final String adUnitId = "demo-rewarded-yandex"; // Use R-M-XXXXXX-Y or demo-block (look for the description below)
    private RewardedAdLoader rewardedAdLoader;
    private RewardedAd rewardedAd;

    private Button loadButton;
    private Button showButton;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        ConstraintLayout rootLayout = new ConstraintLayout(this);
        rootLayout.setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));

        loadButton = new Button(this);
        loadButton.setText("Load Rewarded Ad");
        loadButton.setId(View.generateViewId());

        showButton = new Button(this);
        showButton.setText("Show Rewarded Ad");
        showButton.setId(View.generateViewId());
        showButton.setEnabled(false);

        LayoutParams loadBtnParams = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
        loadBtnParams.topToTop = LayoutParams.PARENT_ID;
        loadBtnParams.bottomToBottom = LayoutParams.PARENT_ID;
        loadBtnParams.startToStart = LayoutParams.PARENT_ID;
        loadBtnParams.endToEnd = LayoutParams.PARENT_ID;
        rootLayout.addView(loadButton, loadBtnParams);

        LayoutParams showBtnParams = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
        showBtnParams.topToBottom = loadButton.getId();
        showBtnParams.startToStart = LayoutParams.PARENT_ID;
        showBtnParams.endToEnd = LayoutParams.PARENT_ID;
        showBtnParams.topMargin = 24;
        rootLayout.addView(showButton, showBtnParams);

        setContentView(rootLayout);

        rewardedAdLoader = new RewardedAdLoader(this);
        rewardedAdLoader.setAdLoadListener(this);

        loadButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                loadRewardedAd();
            }
        });

        showButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                showRewardedAd();
            }
        });
    }

    @Override
    public void onAdLoaded(RewardedAd ad) {
        rewardedAd = ad;
        enableShowButton();
        System.out.println("Rewarded ad loaded!");
    }

    @Override
    public void onAdFailedToLoad(@Nullable AdRequestError error) {}

    private void loadRewardedAd() {
        disableShowButton();
        AdRequestConfiguration config = new AdRequestConfiguration.Builder(adUnitId).build();
        if (rewardedAdLoader != null) {
            rewardedAdLoader.loadAd(config);
        }
    }

    private void showRewardedAd() {
        disableShowButton();
        if (rewardedAd != null) {
            rewardedAd.setAdEventListener(this);
            rewardedAd.show(this);
        }
    }

    private void destroyRewardedAd() {
        if (rewardedAd != null) {
            rewardedAd.setAdEventListener(null);
            rewardedAd = null;
        }
    }

    private void enableShowButton() {
        if (showButton != null) showButton.setEnabled(true);
    }

    private void disableShowButton() {
        if (showButton != null) showButton.setEnabled(false);
    }

    @Override
    protected void onDestroy() {
        if (rewardedAdLoader != null) {
            rewardedAdLoader.setAdLoadListener(null);
            rewardedAdLoader = null;
        }
        destroyRewardedAd();
        super.onDestroy();
    }
    @Override
    public void onAdShown() {}
    @Override
    public void onAdFailedToShow(@Nullable AdError adError) {}
    @Override
    public void onAdDismissed() {
        System.out.println("🚪 Ad dismissed");
        destroyRewardedAd();
        loadRewardedAd(); // Preload new ad
    }
    @Override
    public void onRewarded(Reward reward) {
        System.out.println("🏆 Reward granted: " + reward.getAmount() + " " + reward.getType());
    }
    @Override
    public void onAdClicked() {}
    @Override
    public void onAdImpression(@Nullable ImpressionData data) {}
}

Checking integration

Build and run your project. You can check if the integration is successful by searching the YandexAds keyword in Logcat:

[Integration] Ad type rewarded was integrated successfully
Previous
App open ads
Next
Native ads