Early Access SDK - cleveradssolutions/CAS-Android GitHub Wiki

CAS 4.0 introduces several enhancements to streamline management and improve the stability of in-app ads:

• Unified Management: All ad formats are now managed using a CAS ID string with the new CASAppOpen, CASInterstitial and CASRewarded ad objects. Read more about the new implementation below. Previously, this required working with a MediationManager instance.
• Ad Type Management: Use ManagerBuilder.withAdTypes() only if you continue to use MediationManager for ad requests. For the new CASInterstitial and CASRewarded implementations, you should skip this function call.
• Preloading and Caching: You can now preload and cache multiple instances of ads for each ad format, reducing latency and improving ad display performance.
• Support Native Ad format: Read more about new Native Ad format implementation.
• Single impression listener: All ad objects have OnAdImpressionListener to collect impression data via new AdContent structure. Read more below.
• User ID Specification: The CAS.targetingOptions.userId property is now available for specifying the User ID. The previous method using ManagerBuilder.withUserID() has been deprecated.
• Banner View Constructor: A new constructor for CASBannerView has been added that accepts a CAS ID parameter. The old constructor that accepted a MediationManager parameter is now deprecated.

• Includes adapter updates from version 3.9.8.
• Update for AppOpen, Interstitial, Rewarded:
  • The screen ad instance can now be loaded if it will only be used in ScreenAdContentCallback. Make sure to call destroy() to release application resources.
  • The screen ad instances no longer requires a context to create (context can be optionally null).
  • The load() method for screen ads is deprecated in favor of load(Context?).
  • The show(Activity?) method for screen ads no longer requires an Activity, but it is still recommended to pass an Activity when possible. The CAS SDK will attempt to determine the last created Activity of your app.

• Update for Native format:
  • CASMediaView can now have a size of WRAP_CONTENT. In this case, it will use all available space while maintaining the aspect ratio of the ad content.
  • NativeAdContent can now be set repeatedly to CASNativeView without causing an error. However, note that you should avoid situations where the same NativeAdContent is set to multiple CASNativeView instances simultaneously. Also, make sure to always call destroy() for NativeAdContent that is no longer in use, in order to release application resources.
  • The CASNativeView.setNativeAdTemplate(NativeAdContent, AdSize) method is now deprecated in favor of the new setAdTemplateSize(AdSize) method. This new method still creates a view layout with the specified size, but now you must call setNativeAd(NativeAdContent) to populate the content.

• Added automatic initialization of the Tenjin SDK when you provide the API key in the CAS SDK initialization parameters. The CAS SDK will handle the connect(), optIn(), or optOut() functions calls for Tenjin SDK.

CAS.buildManager()
   .withMediationExtras("tenjin_key", <TENJIN_SDK_KEY>)
   .build(this)

• Fixed java.lang.ClassCastException: LayoutParams cannot be cast to MarginLayoutParams from CASNativeView.
• Fixed a tracking issues for YsoNetwork and Yandex Ads impressions.
• Fixed an issue where Mintegral video ads would not play in their native format.
• Fixed an issue where Mintegral AppOpen ads could show underneath existing dialogs.
• Fixed a rare issue where on some tablets the banner size would load in Leaderboard format instead of the normal one.

maven {  
    name = "YSOAdsRepo"  
    url = "https://ysonetwork.s3.eu-west-3.amazonaws.com/sdk/android"  
    content { it.includeGroup("com.ysocorp") }  
}

cas {
    adapters {
        ysoNetwork = true
    }
}

In addition to the lines described in the Add Maven repositories section, please add the beta maven repository to your settings.gradle file.

pluginManagement {  
    repositories {  
        ...  
        maven {  
            name = "CASBetaRepo"  
            url = "https://repo.repsy.io/mvn/cleveradssolutions/beta"  
        }  
    }
}

dependencyResolutionManagement {  
    repositories {  
        ...
        maven {  
            name = "CASBetaRepo"  
            url = "https://repo.repsy.io/mvn/cleveradssolutions/beta"  
            content { it.includeGroup("com.cleveradssolutions") }  
        }
    }
}

Continue with Plugin integration, using the beta version in app-level build.gradle:

plugins {
    id("com.cleveradssolutions.gradle-plugin") version "4.0.0-beta9"
}

cas {
    ...
}

In most cases, a casId is the same as your application package name.

val casId = BuildConfig.APPLICATION_ID

You can skip the manual call for ad initialization, and then the SDK will automatically perform the initialization before the first ad load. However, if it's important for you to change the configuration or listen to states of the Consent Flow, make sure to initialize it at least once before the first ad load.

override fun onCreate() {  
    super.onCreate()
    
    CAS.buildManager()  
        .withManagerId(casId)
        .withTestAdMode(BuildConfig.DEBUG)
        .withConsentFlow(  
            ConsentFlow(isEnabled = true)  
                .withDismissListener {  
                    Log.d(TAG, "Consent flow dismissed")  
                }  
        )  
        .withCompletionListener {  
            if (it.error == null) {  
                Log.d(TAG, "Ads initialized")  
            } else {  
                Log.d(TAG, "Ads initialization failed: " + it.error)  
            }  
        }  
        .build(this)
}

If enabled, the ad will automatically load new content when the current ad is dismissed or completed. Additionally, it will automatically retry loading the ad if an error occurs during the loading process.

(Deprecated) Previously, you used settings to choose between automatic or manual loading modes.

CAS.settings.loadingMode = LoadingManagerMode.Manual

With the update to CAS 4.0, you can now configure automatic loading individually for each ad object. Below is an example of using the isAutoloadEnabled property and the default value for each ad format.

bannerView.isAutoloadEnabled = CAS.settings.loadingMode != LoadingManagerMode.Manual

interstitialAd.isAutoloadEnabled = false
rewardedAd.isAutoloadEnabled = false
appOpenAd.isAutoloadEnabled = false

The CASNativeLoader does not have an autoload ad mode.

A functional interface for listening to ad impression events.

val impressionListener = OnAdImpressionListener { ad: AdContent ->  
    // Called when an ad impression occurs.  
}

Each ad format has an onImpressionListener property within the ad object for registering a listener.

The deprecated AdImpression (AdStatusHandler) has been replaced by the new AdContent data structure, which contains information about the loaded/displayed ad. You can access AdContent using OnAdImpressionListener, ScreenAdContentCallback, or NativeAdContentCallback.

Read more about new Native Ad format implementation.

A abstract class for handling events related to screen ad content.

val screenCallback = object : ScreenAdContentCallback(){  
    override fun onAdLoaded(ad: AdContent) {  
        // Called when the ad content has been successfully loaded.  
    }  
    override fun onAdFailedToLoad(format: AdFormat, error: AdError) {  
        // Called when the ad content fails to load.  
    }  
    override fun onAdFailedToShow(format: AdFormat, error: AdError) {  
        // Called when the ad content fails to show.  
    }  
    override fun onAdShowed(ad: AdContent) {  
        // Called when the ad content is successfully shown.  
    }  
    override fun onAdClicked(ad: AdContent) {  
        // Called when the ad content is clicked by the user.  
    }  
    override fun onAdDismissed(ad: AdContent) {  
        // Called when the ad content is dismissed.  
    }  
}

The App Open Ad format has been newly implemented in the com.cleveradssolutions.sdk.screen.CASAppOpen class.

// Can be initialized along with the activity.
val appOpenAd = CASAppOpen(casId)

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // Optionally, you can register listeners.
    appOpenAd.contentCallback = screenCallback
    appOpenAd.onImpressionListener = impressionListener
}

override fun onResume() {  
    super.onResume()  
    if (appOpenAd.isLoaded) {
        appOpenAd.show(this)
    } else {
        appOpenAd.load(this)
    }
}

override fun onDestroy() {
    appOpenAd.destroy()
    super.onDestroy()  
}

The Interstitial Ad format has been newly implemented in the com.cleveradssolutions.sdk.screen.CASInterstitial class.

// Can be initialized along with the activity.
val interstitialAd = CASInterstitial(casId)

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // Optionally, you can register listeners.
    interstitialAd.contentCallback = screenCallback
    interstitialAd.onImpressionListener = impressionListener

    interstitialAd.isAutoloadEnabled = false // Disabled by default
}

fun loadInterstitialAd() {
    if (interstitialAd.isAutoloadEnabled == false) {
        interstitialAd.load(this)
    }
}

// Not mandatory, but you can check the ad loaded
fun isInterstitialAdLoaded(): Boolean {
    return interstitialAd.isLoaded
}

fun showInterstitialAd() {
    interstitialAd.show(this)
}

override fun onDestroy() {
    interstitialAd.destroy()
    super.onDestroy()  
}

Attempting to show a new ad within this interval after the previous ad has closed will result in a call to ScreenAdContentCallback.onAdFailedToShow with AdErrorCode.NOT_PASSED_INTERVAL. By default, this interval is set to 0 seconds, or it uses the global CAS.settings.interstitialInterval value.

interstitialAd.minInterval = 0

Automatic display of App Return Ads is available for CASAppOpen and CASInterstitial. To enable this feature, use the isAutoshowEnabled property. Note that the ad must be ready for display at the time of returning to the app. Disabled by default.

appOpenAd.isAutoshowEnabled = true
interstitialAd.isAutoshowEnabled = true

The Interstitial Ad format has been newly implemented in the `com.cleveradssolutions.sdk.screen.CASRewarded class.

// Can be initialized along with the activity.
val rewardedAd = CASRewarded(casId)

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // Optionally, you can register listeners.
    rewardedAd.contentCallback = screenCallback
    rewardedAd.onImpressionListener = impressionListener

    rewardedAd.isAutoloadEnabled = false // Disabled by default
}

fun loadRewardedAd() {
    if (rewardedAd.isAutoloadEnabled == false) {
        rewardedAd.load(this)
    }
}

// Not mandatory, but you can check the ad loaded
fun isRewardedAdLoaded(): Boolean {
    return rewardedAd.isLoaded
}

fun showRewardedAd() {
    rewardedAd.show(this) { ad: AdContent ->
        // Called when a user earns a reward from the ad.
    }
}

override fun onDestroy() {
    rewardedAd.destroy()
    super.onDestroy()  
}

• The AdError.message provides more detailed error information. There can be multiple detailed messages for a single error code.
• All error code constants moved from AdError to AdErrorCode.
• New errors have been added: AdErrorCode.TIMEOUT and AdErrorCode.NOT_INITIALIZED.