Load Ads

Creating Fullscreen Ads 🔗

The new Fullscreen APIs combine the existing Rewarded and Interstitial ad formats with the new Rewarded Interstitial ad format into a single integration experience. The older APIs have been marked deprecated, but are still functional until the 5.0.0 SDK release.

To show a Fullscreen ad, create a Fullscreen ad load request using the Placement Name you set up on your Chartboost platform.

• Kotlin
• Java

• // While in a coroutine
  val adRequest = ChartboostMediationAdLoadRequest(
     placementName = [Your Placement Name],
     keywords = Keywords(),
  )
  
  val loadResult = HeliumSdk.loadFullscreenAd(
         context,
         adRequest,
         object : ChartboostMediationFullscreenAdListener {
             override fun onAdImpressionRecorded(ad: ChartboostMediationFullscreenAd) {
                 // Impression
             }
  
             override fun onAdClicked(ad: ChartboostMediationFullscreenAd) {
                 // Clicked
             }
  
             override fun onAdRewarded(ad: ChartboostMediationFullscreenAd) {
                 // Rewarded
             }
  
             override fun onAdExpired(ad: ChartboostMediationFullscreenAd) {
                 // Expired
             }
  
             override fun onAdClosed(
                 ad: ChartboostMediationFullscreenAd,
                 error: ChartboostMediationAdException?
             ) {
                 // Closed
             }
         }
     )
  }
  
  

• ChartboostMediationAdLoadRequest adRequest = new ChartboostMediationAdLoadRequest([Your Placement Name], new Keywords());
  
  HeliumSdk.loadFullscreenAdFromJava(
         context,
         adRequest,
         new ChartboostMediationFullscreenAdListener() {
             public void onAdImpressionRecorded(@NonNull ChartboostMediationFullscreenAd ad) {
                 // Impression
             }
  
             public void onAdClicked(@NonNull ChartboostMediationFullscreenAd ad) {
                 // Clicked
             }
  
             public void onAdRewarded(@NonNull ChartboostMediationFullscreenAd ad) {
                 // Rewarded
             }
  
             public void onAdExpired(@NonNull ChartboostMediationFullscreenAd ad) {
                 // Expired
             }
  
             public void onAdClosed(
                 @NonNull ChartboostMediationFullscreenAd ad,
                 @Nullable ChartboostMediationAdException error) {
                 // Closed
             }
         },
         new ChartboostMediationFullscreenAdLoadListener() {
             public void onAdLoaded(@NonNull ChartboostMediationFullscreenAd ad) {
                 // Loaded
             }
         }
     )
  }
  
  

Banner Ads for SDK 4.6.0+ 🔗

Mediation SDK 4.6.0 introduces a new Adaptive Banner ad format, capable of serving flexible and fixed sized ads in the placement. The new Adaptive Banner ad format has the following features:

• Publishers can choose whether to use Adaptive Ads or Fixed Ads in a given placement.
• Fixed Ads are supported in Adaptive Ad placements (backwards compatible).
• Publishers should know whether an ad is fixed or flexible and receive the dimensions of fixed ads.
• Publishers can align the ad horizontally and/or vertically.
• Publishers can resize the ad container to fit the ad or optionally discard oversized ads that are rendered in the container.
• The ad container can be in-line or on top of publisher content.

To use this new ad format, Publishers will need to create a new Adaptive Banner placement in their platform and integrate with the new Adaptive Banner APIs.

Loading Banner Ads 🔗

The API class HeliumBannerSize will support both fixed and adaptive banners:

• Kotlin

• // To load an adaptive 6x1 ad (with width 300dp)
  heliumBannerAd.load(placement, HeliumBannerSize.adaptive6x1(300))
      // You can pass in another size or the old non-adaptive sizes such as HeliumBannerSize.STANDARD
  
  // To listen for refreshes
  val listener: HeliumBannerAdListener = object : HeliumBannerAdListener {
      fun onAdViewAdded(placementName: String, child: View?) {
          // notified that a view is added.
      }
      // other callbacks didn't change
  }
  heliumBannerAd.heliumBannerAdListener = listener
  

Resizing Adaptive Banner Container 🔗

• Kotlin

• val density = context.resources.displayMetrics.density
  heliumBannerAd.layoutParams = ViewGroup.LayoutParams(
                      300 * density,
                      50 * density
                  )
  // If you want this to be automatic, just use WRAP_CONTENT for
  // both width and height.
  heliumBannerAd.layoutParams = ViewGroup.LayoutParams(
                      ViewGroup.LayoutParams.WRAP_CONTENT,
                      ViewGroup.LayoutParams.WRAP_CONTENT
                  )
  // You can change this anytime. The next ad will use these sizes.
  
  // To get the size of the currently showing creative, see:
  heliumBannerAd.getCreativeSizeDips()
  

Discarding Oversized Ads 🔗

The setShouldDiscardOversizedAds will allow you the option to discard or allow ads larger than what is set for HeliumBannerSize.

• Kotlin

• // To drop oversized ads
  HeliumSdk.setShouldDiscardOversizedAds(true)
  
  // To allow oversized ads
  HeliumSdk.setShouldDiscardOversizedAds(false)
  

Banner Ads for SDK 4.5.x and prior 🔗

Creating Banner Ads 🔗

There are two ways to create banners on Android:

• programmatically
• XML

The following banner sizes can be passed down. Some partners may not fill for some banner sizes.

Create Banner Ads Programmatically 🔗

The following Fixed Ad Size APIs are deprecated starting SDK 4.6.0 but are still supported

1. Declare a variable to hold a reference to the Banner Mediation Ad.
2. Supply the corresponding Placement Name and Banner Size

• Kotlin
• Java

• /*
    The following Banner enum Sizes can be passed down:
    HeliumBannerAd.HeliumBannerSize.STANDARD
    HeliumBannerAd.HeliumBannerSize.MEDIUM
    HeliumBannerAd.HeliumBannerSize.LEADERBOARD
  */
  val bannerSize = HeliumBannerAd.HeliumBannerSize.STANDARD
  val heliumBannerAd = new HeliumBannerAd(context, placementName, bannerSize, bannerListener)
  

• ...
    <com.chartboost.heliumsdk.ad.HeliumBannerAd
        android:id="@+id/bannerAd"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        tools:layout_height="50dp"
        app:heliumBannerSize="STANDARD"
        app:heliumPlacementName="PlacementName" />
  ...
  

Loading Banner Ads 🔗

For Mediation SDK 3.0.0:

• load() returns a String representing the load request identifier. This return value is optional to consume.
• Banners are now automatically shown. Add this banner view to the view hierarchy and the ads will automatically be shown.

You will need to create an ad instance for each placement name you want to use. Finally, make the call to load the ad:

• Kotlin
• Java

• // load() returns a String representing the load request identifier.
  heliumBannerAd.load()
  

• // load() returns a String representing the load request identifier.
  heliumBannerAd.load();
  

Clearing Loaded Ads 🔗

Clearing loaded ads may be necessary on existing placements to request another ad (i.e. for an in-house programmatic auction).

Clearing Interstitial and Rewarded Ads 🔗

• Kotlin
• Java

• heliumInterstitialAd.clearLoaded()
  heliumRewardedAd.clearLoaded()
  

• heliumInterstitialAd.clearLoaded();
  heliumRewardedAd.clearLoaded();
  

Clearing Banner Ads 🔗

For Mediation SDK 3.0.0 on banners:

• Call clearAd() to clear the currently displayed and cached banner ad.

• Kotlin
• Java

• // To clear currently showing and any cached ad loaded for auto refresh.
  heliumBannerAd.clearAd()
  

• // To clear currently showing and any cached ad loaded for auto refresh.
  heliumBannerAd.clearAd();
  

The 3.x.x clearAd and 2.x.x clearLoaded API returns a boolean and indicates if the ad object has been cleared and is ready for another load call.