diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
new file mode 100644
index 0000000..9e3a702
--- /dev/null
+++ b/.github/workflows/ci.yaml
@@ -0,0 +1,27 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    name: Run tests
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          distribution: 'zulu'
+          java-version: '17'
+      - name: Run unit tests
+        run: ./gradlew testDebugUnitTest
+      - name: Display unit test results
+        uses: mikepenz/action-junit-report@v4
+        if: always()
+        with:
+          check_name: 'Unit tests: Results'
+          report_paths: '**/build/test-results/testDebugUnitTest/TEST-*.xml'
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b1aa118..981a938 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,9 +6,74 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
-## 2.2.1 - 2023-08-10
+### Added
+- Support for reporting the stack trace in case of error events, if provided by the player
+
+## 2.7.2 - 2024-10-28
+
+### Added
+- Default value of `false` for `c3.ad.isSlate` for client side ad insertion per Conviva Custom Ad Manager integration docs
+
+## 2.7.1 - 2024-09-24
+### Fixed
+- Reporting wrong ad position for mid-roll VMAP ads
+
+## 2.7.0 - 2024-09-05
+### Fixed
+- Potential integration error shown in Touchstone if the player emits a warning outside of an active Conviva session
+
+### Changed
+- Updated Bitmovin Player to `3.81.0`
+
+## 2.6.0 - 2024-08-28
+### Added
+- `averageBitrate` to reported video metrics
+- Possibility to start session tracking without a `Player` instance
+  - `ConvivaAnalyticsIntegration(customerKey:config:)` constructor without a `Player`
+  - `ConvivaAnalyticsIntegration.attachPlayer()` to attach the `Player` at a later point in the session life-cycle
+
+### Removed
+- Unintentionally public initializers from `ConvivaAnalyticsIntegration` which were not intended to be public and only meant for testing
+
+### Changed
+- Updated Bitmovin Player to `3.78.2`
+- Updated conviva-core to `4.0.39`
+
+## 2.5.0 - 2024-07-05
+### Added
+- `ConvivaAnalyticsIntegration.ssai` namespace to enable server side ad tracking
+
+### Fixed
+- Potential exception when determining the IMA SDK version on ad start
+
+## 2.4.0 - 2024-06-06
+### Added
+- Ad analytics for ad event reporting
+
+### Changed
+- Updated Bitmovin Player to `3.71.0`
+- Updated IMA SDK to `3.31.0`
+- Updated conviva-core to `4.0.37`
+- Increased minimum required `compileSdk` version to `34`
+- Increased `compileSdk` and `targetSdkVersion` to `34`
+- Increased `minSdkVersion` to `19`
+- Ad break started and ended is now reported in `PlayerEvent.AdBreakStarted` and `PlayerEvent.AdBreakFinished`
+- Updated Kotlin to `1.9.23`
+- Updated Gradle wrapper to `8.2` and AGP to `8.2.2`
+
+### Removed
+- Custom event for `AdSkipped` and `AdError`. Replaced by Conviva build in tracking
+
+### Fixed
+- The pom file now also includes the `com.bitmovin.player` dependency which was missing before
+
+## 2.3.0 - 2024-05-21
+### Added
+- New `TimeChanged` callback for reporting Playhead to conviva playback metric. Calculates Live and Vod playback for report.
+- New `MetadataOverrides.setAdditionalStandardTags` that allows to set additional standard tags for the session. The List of tags can be found here: [Pre-defined Video and Content Metadata](https://pulse.conviva.com/learning-center/content/sensor_developer_center/sensor_integration/android/android_stream_sensor.htm#PredefinedVideoandContentMetadata)
+
 ### Changed
-- Updated Conviva SDK to 4.0.33
+- Updated conviva-core to 4.0.35
 
 ## 2.2.0 - 2023-07-18
 ### Added
diff --git a/ConvivaExampleApp/build.gradle b/ConvivaExampleApp/build.gradle
index 41eeceb..a7d2d2f 100644
--- a/ConvivaExampleApp/build.gradle
+++ b/ConvivaExampleApp/build.gradle
@@ -1,7 +1,8 @@
 apply plugin: 'com.android.application'
 
 android {
-    compileSdkVersion rootProject.compileSdkVersion
+    compileSdk rootProject.compileSdkVersion
+
     defaultConfig {
         applicationId "com.bitmovin.analytics.convivaanalyticsexample"
         minSdkVersion rootProject.minSdkVersion
diff --git a/ConvivaExampleApp/src/main/java/com/bitmovin/analytics/convivaanalyticsexample/MainActivity.java b/ConvivaExampleApp/src/main/java/com/bitmovin/analytics/convivaanalyticsexample/MainActivity.java
index 79ddf68..7b31197 100644
--- a/ConvivaExampleApp/src/main/java/com/bitmovin/analytics/convivaanalyticsexample/MainActivity.java
+++ b/ConvivaExampleApp/src/main/java/com/bitmovin/analytics/convivaanalyticsexample/MainActivity.java
@@ -1,46 +1,56 @@
 package com.bitmovin.analytics.convivaanalyticsexample;
 
 import android.os.Bundle;
-import androidx.appcompat.app.AppCompatActivity;
-
+import android.util.Log;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.Button;
 import android.widget.LinearLayout;
 import android.widget.Switch;
 
-import com.bitmovin.analytics.conviva.ConvivaAnalyticsIntegration;;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AppCompatActivity;
+
+import com.bitmovin.analytics.conviva.ConvivaAnalyticsException;
+import com.bitmovin.analytics.conviva.ConvivaAnalyticsIntegration;
 import com.bitmovin.analytics.conviva.ConvivaConfig;
 import com.bitmovin.analytics.conviva.MetadataOverrides;
-import com.bitmovin.player.api.Player;
 import com.bitmovin.player.PlayerView;
-import com.bitmovin.player.api.source.SourceConfig;
+import com.bitmovin.player.api.Player;
+import com.bitmovin.player.api.PlayerBuilder;
 import com.bitmovin.player.api.PlayerConfig;
 import com.bitmovin.player.api.advertising.AdItem;
 import com.bitmovin.player.api.advertising.AdSource;
 import com.bitmovin.player.api.advertising.AdSourceType;
 import com.bitmovin.player.api.advertising.AdvertisingConfig;
+import com.bitmovin.player.api.source.SourceConfig;
 import com.bitmovin.player.api.source.SourceType;
 
 import java.util.HashMap;
 import java.util.Map;
 
 public class MainActivity extends AppCompatActivity implements View.OnClickListener {
+    private static final String TAG = "Example";
+
     // UI
     private Button pauseTrackingButton;
     private Button resumeTrackingButton;
     private Button releaseButton;
     private Button createButton;
     private Button sendCustomEventButton;
+    private Button startSessionButton;
     private Switch includeAdsSwitch;
 
     // Conviva
     private static final String customerKey = "YOUR-CUSTOMER-KEY";
     private static String gatewayUrl; // Set only in debug mode
+    @Nullable
     private ConvivaAnalyticsIntegration convivaAnalyticsIntegration;
 
     // Player
+    @Nullable
     private Player bitmovinPlayer;
+    @Nullable
     private PlayerView bitmovinPlayerView;
 
     @Override
@@ -53,52 +63,35 @@ protected void onCreate(Bundle savedInstanceState) {
         resumeTrackingButton.setOnClickListener(this);
         releaseButton = findViewById(R.id.release_button);
         releaseButton.setOnClickListener(this);
-        createButton = findViewById(R.id.create_button);
+        createButton = findViewById(R.id.create_player_button);
         createButton.setOnClickListener(this);
         sendCustomEventButton = findViewById(R.id.custom_event_button);
         sendCustomEventButton.setOnClickListener(this);
+        startSessionButton = findViewById(R.id.start_session_button);
+        startSessionButton.setOnClickListener(this);
         includeAdsSwitch = findViewById(R.id.include_ads_switch);
 
         this.setupBitmovinPlayer();
     }
 
     protected void setupBitmovinPlayer() {
-        this.bitmovinPlayer = Player.create(this, buildPlayerConfiguration());
+        this.bitmovinPlayer = new PlayerBuilder(this)
+                .setPlayerConfig(buildPlayerConfiguration())
+                .disableAnalytics()
+                .build();
         this.bitmovinPlayerView = new PlayerView(this, this.bitmovinPlayer);
 
         LinearLayout playerUIView = this.findViewById(R.id.bitmovinPlayerUIView);
         playerUIView.addView(bitmovinPlayerView);
 
-        // Create your ConvivaConfig object
-        ConvivaConfig convivaConfig = new ConvivaConfig();
-
-        // Set only in debug mode
-        if (gatewayUrl != null) {
-            convivaConfig.setGatewayUrl(gatewayUrl);
+        if (convivaAnalyticsIntegration == null) {
+            convivaAnalyticsIntegration = setupConvivaAnalytics(bitmovinPlayer);
+        } else {
+            convivaAnalyticsIntegration.attachPlayer(bitmovinPlayer);
         }
 
-        // Add optional parameters
-        convivaConfig.setDebugLoggingEnabled(true);
-
-        // Create ConvivaAnalytics
-        convivaAnalyticsIntegration = new ConvivaAnalyticsIntegration(
-                bitmovinPlayer,
-                customerKey,
-                getApplicationContext(),
-                convivaConfig);
-
-
-        MetadataOverrides metadata = new MetadataOverrides();
-        metadata.setApplicationName("Bitmovin Android Conviva integration example app");
-        metadata.setViewerId("awesomeViewerId");
-        Map<String, String> customInternTags = new HashMap<>();
-        customInternTags.put("contentType", "Episode");
-        metadata.setCustom(customInternTags);
-        convivaAnalyticsIntegration.updateContentMetadata(metadata);
-
         // load source using the created source configuration
         bitmovinPlayer.load(buildSourceConfiguration());
-
     }
 
     private PlayerConfig buildPlayerConfiguration() {
@@ -108,6 +101,8 @@ private PlayerConfig buildPlayerConfiguration() {
             playerConfiguration.setAdvertisingConfig(buildAdConfiguration());
         }
 
+        playerConfiguration.getPlaybackConfig().setAutoplayEnabled(true);
+
         return playerConfiguration;
     }
 
@@ -132,35 +127,136 @@ private AdvertisingConfig buildAdConfiguration() {
         return new AdvertisingConfig(preRoll);
     }
 
+    @Override
+    protected void onStart() {
+        super.onStart();
+        if (bitmovinPlayerView != null) {
+            bitmovinPlayerView.onStart();
+        }
+    }
+
     @Override
     protected void onResume() {
         super.onResume();
-        bitmovinPlayerView.onResume();
-        convivaAnalyticsIntegration.reportAppForegrounded();
+        if (bitmovinPlayerView != null) {
+            bitmovinPlayerView.onResume();
+        }
     }
 
     @Override
     protected void onPause() {
-        convivaAnalyticsIntegration.reportAppBackgrounded();
-        bitmovinPlayerView.onStop();
         super.onPause();
+        if (bitmovinPlayerView != null) {
+            bitmovinPlayerView.onPause();
+        }
     }
 
     @Override
-    protected void onDestroy() {    
-        bitmovinPlayerView.onDestroy();
-        convivaAnalyticsIntegration.release();
+    protected void onStop() {
+        super.onStop();
+        if (bitmovinPlayerView != null) {
+            bitmovinPlayerView.onStop();
+        }
+    }
+
+    @Override
+    protected void onDestroy() {
         super.onDestroy();
+        if (bitmovinPlayerView != null) {
+            bitmovinPlayerView.onDestroy();
+        }
+        if (convivaAnalyticsIntegration != null) {
+            convivaAnalyticsIntegration.release();
+            convivaAnalyticsIntegration = null;
+        }
     }
 
     private void tearDownPlayer() {
-        convivaAnalyticsIntegration.release();
-        ViewGroup parent = (ViewGroup) bitmovinPlayerView.getParent();
+        if (convivaAnalyticsIntegration != null) {
+            convivaAnalyticsIntegration.release();
+            convivaAnalyticsIntegration = null;
+        }
+        ViewGroup parent = null;
+        if (bitmovinPlayerView != null) {
+            parent = (ViewGroup) bitmovinPlayerView.getParent();
+        }
         if (parent != null) {
             parent.removeView(bitmovinPlayerView);
         }
-        bitmovinPlayer.destroy();
-        bitmovinPlayerView.onDestroy();
+        if (bitmovinPlayer != null) {
+            bitmovinPlayer.destroy();
+        }
+        if (bitmovinPlayerView != null) {
+            bitmovinPlayerView.onDestroy();
+        }
+        bitmovinPlayer = null;
+    }
+
+    private void startSession() {
+        ConvivaAnalyticsIntegration convivaAnalyticsIntegration = setupConvivaAnalytics(bitmovinPlayer);
+        convivaAnalyticsIntegration.updateContentMetadata(buildMetadataOverrides("Art of Motion"));
+        try {
+            convivaAnalyticsIntegration.initializeSession();
+
+            this.convivaAnalyticsIntegration = convivaAnalyticsIntegration;
+        } catch (ConvivaAnalyticsException e) {
+            Log.d(TAG, "ConvivaAnalytics initialization failed with error: " + e);
+        }
+    }
+
+    private ConvivaAnalyticsIntegration setupConvivaAnalytics(@Nullable Player player) {
+        // Create your ConvivaConfig object
+        ConvivaConfig convivaConfig = new ConvivaConfig();
+
+        // Set only in debug mode
+        if (gatewayUrl != null) {
+            convivaConfig.setGatewayUrl(gatewayUrl);
+        }
+
+        ConvivaAnalyticsIntegration convivaAnalyticsIntegration = null;
+        // Add optional parameters
+        convivaConfig.setDebugLoggingEnabled(true);
+
+        if (player != null) {
+            convivaAnalyticsIntegration = new ConvivaAnalyticsIntegration(
+                    player,
+                    customerKey,
+                    getApplicationContext(),
+                    convivaConfig
+            );
+        } else {
+            convivaAnalyticsIntegration = new ConvivaAnalyticsIntegration(
+                    customerKey,
+                    getApplicationContext(),
+                    convivaConfig
+            );
+        }
+
+        convivaAnalyticsIntegration.updateContentMetadata(buildMetadataOverrides(null));
+
+        return convivaAnalyticsIntegration;
+    }
+
+    private MetadataOverrides buildMetadataOverrides(@Nullable String assetName) {
+        MetadataOverrides metadata = new MetadataOverrides();
+        metadata.setApplicationName("Bitmovin Android Conviva integration example app");
+        metadata.setViewerId("awesomeViewerId");
+
+        Map<String, Object> standardTags = new HashMap<>();
+        standardTags.put("c3.cm.contentType", "VOD");
+        metadata.setAdditionalStandardTags(standardTags);
+
+        Map<String, String> customTags = new HashMap<>();
+        customTags.put("custom_tag", "Episode");
+        metadata.setCustom(customTags);
+
+        metadata.setImaSdkVersion("3.31.0");
+
+        if (assetName != null) {
+            metadata.setAssetName(assetName);
+        }
+
+        return metadata;
     }
 
     @Override
@@ -172,12 +268,19 @@ public void onClick(View v) {
         } else if (v == sendCustomEventButton) {
             Map<String, Object> eventAttributes = new HashMap<>();
             eventAttributes.put("Some", "Attributes");
-            this.convivaAnalyticsIntegration.sendCustomPlaybackEvent("Custom Event", eventAttributes);
+            if (this.convivaAnalyticsIntegration != null) {
+                this.convivaAnalyticsIntegration.sendCustomPlaybackEvent("Custom Event", eventAttributes);
+            }
         } else if (v == pauseTrackingButton) {
-            this.convivaAnalyticsIntegration.pauseTracking(false);
+            if (this.convivaAnalyticsIntegration != null) {
+                this.convivaAnalyticsIntegration.pauseTracking(false);
+            }
         } else if (v == resumeTrackingButton) {
-            this.convivaAnalyticsIntegration.resumeTracking();
+            if (this.convivaAnalyticsIntegration != null) {
+                this.convivaAnalyticsIntegration.resumeTracking();
+            }
+        } else if (v == startSessionButton) {
+            this.startSession();
         }
     }
 }
-
diff --git a/ConvivaExampleApp/src/main/res/layout/activity_main.xml b/ConvivaExampleApp/src/main/res/layout/activity_main.xml
index 8d1a73a..58de572 100644
--- a/ConvivaExampleApp/src/main/res/layout/activity_main.xml
+++ b/ConvivaExampleApp/src/main/res/layout/activity_main.xml
@@ -7,6 +7,18 @@
     android:keepScreenOn="true"
     tools:context=".MainActivity">
 
+    <Button
+        android:id="@+id/start_session_button"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_marginStart="16dp"
+        android:layout_marginEnd="16dp"
+        android:text="@string/start_session"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintHorizontal_weight="1"
+        app:layout_constraintStart_toEndOf="@+id/custom_event_button"
+        app:layout_constraintTop_toTopOf="@+id/custom_event_button" />
+
     <LinearLayout
         android:id="@+id/bitmovinPlayerUIView"
         android:layout_width="match_parent"
@@ -46,15 +58,13 @@
 
     <Button
         android:id="@+id/custom_event_button"
-        android:layout_width="wrap_content"
+        android:layout_width="0dp"
         android:layout_height="wrap_content"
         android:layout_marginStart="16dp"
-        android:layout_marginLeft="16dp"
         android:layout_marginTop="16dp"
         android:layout_marginEnd="16dp"
-        android:layout_marginRight="16dp"
         android:text="@string/send_custom_event"
-        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintEnd_toStartOf="@+id/create_player_button"
         app:layout_constraintStart_toStartOf="parent"
         app:layout_constraintTop_toBottomOf="@+id/release_button" />
 
@@ -63,18 +73,16 @@
         android:layout_width="0dp"
         android:layout_height="wrap_content"
         android:layout_marginStart="16dp"
-        android:layout_marginLeft="16dp"
         android:layout_marginTop="16dp"
         android:layout_marginEnd="16dp"
-        android:layout_marginRight="16dp"
         android:text="@string/release"
-        app:layout_constraintEnd_toStartOf="@+id/create_button"
+        app:layout_constraintEnd_toStartOf="@+id/create_player_button"
         app:layout_constraintHorizontal_weight="1"
         app:layout_constraintStart_toStartOf="parent"
         app:layout_constraintTop_toBottomOf="@+id/pause_tracking_button" />
 
     <Button
-        android:id="@+id/create_button"
+        android:id="@+id/create_player_button"
         android:layout_width="0dp"
         android:layout_height="wrap_content"
         android:layout_marginEnd="16dp"
diff --git a/ConvivaExampleApp/src/main/res/values/strings.xml b/ConvivaExampleApp/src/main/res/values/strings.xml
index 8de9ada..3fd4aec 100644
--- a/ConvivaExampleApp/src/main/res/values/strings.xml
+++ b/ConvivaExampleApp/src/main/res/values/strings.xml
@@ -4,4 +4,5 @@
     <string name="release">Release</string>
     <string name="create">Create</string>
     <string name="include_ads">Include Ads</string>
+    <string name="start_session">Start Session</string>
 </resources>
diff --git a/ConvivaTestApp/build.gradle b/ConvivaTestApp/build.gradle
index 6de412a..1f6d9f1 100644
--- a/ConvivaTestApp/build.gradle
+++ b/ConvivaTestApp/build.gradle
@@ -4,8 +4,7 @@ plugins {
 }
 
 android {
-    compileSdkVersion rootProject.compileSdkVersion
-    buildToolsVersion "30.0.3"
+    compileSdk rootProject.compileSdkVersion
 
     defaultConfig {
         applicationId "com.bitmovin.analytics.conviva.testapp"
@@ -38,7 +37,7 @@ android {
 }
 
 dependencies {
-    implementation 'androidx.appcompat:appcompat:1.2.0'
+    implementation 'androidx.appcompat:appcompat:1.6.1'
     implementation bitmovinPlayerDependencies.bitmovinPlayer
 
     implementation "com.google.ads.interactivemedia.v3:interactivemedia:$googleImaSdk" // only needed if ads are used:
@@ -54,5 +53,5 @@ dependencies {
     testImplementation testingDependencies.junit
     androidTestImplementation testingDependencies.androidx_junit
     androidTestImplementation testingDependencies.androidx_espresso_core
-    androidTestImplementation testingDependencies.mockk
+    androidTestImplementation testingDependencies.mockk_android
 }
diff --git a/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/AdsTrackingTests.kt b/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/AdsTrackingTests.kt
index 1fad1ef..81696f3 100644
--- a/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/AdsTrackingTests.kt
+++ b/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/AdsTrackingTests.kt
@@ -1,6 +1,7 @@
 package com.bitmovin.analytics.conviva.testapp
 
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.bitmovin.analytics.conviva.testapp.framework.Sources
 import com.conviva.api.*
 import com.conviva.sdk.ConvivaSdkConstants
 import io.mockk.*
@@ -9,13 +10,11 @@ import org.junit.runner.RunWith
 
 @RunWith(AndroidJUnit4::class)
 class AdsTrackingTests : TestBase() {
-    val VMAP_PREROLL_SINGLE_TAG = "https://pubads.g.doubleclick.net/gampad/ads?sz=640x480&iu=/124319096/external/ad_rule_samples&ciu_szs=300x250&ad_rule=1&impl=s&gdfp_req=1&env=vp&output=vmap&unviewed_position_start=1&cust_params=deployment%3Ddevsite%26sample_ar%3Dpreonly&cmsid=496&vid=short_onecue&correlator="
-
     @Test
     fun test_adEventsVmapPrerollSingleAd() {
         // launch player with autoPlay enabled
         val metadata = defaultMetadataOverrides()
-        activityScenario = setupPlayerActivityForTest(autoPlay = true, metadata, VMAP_PREROLL_SINGLE_TAG)
+        activityScenario = setupPlayerActivityForTest(autoPlay = true, metadata, Sources.Ads.VMAP_PREROLL_SINGLE_TAG)
 
         // initialize session and verify
         initializeSession(activityScenario)
diff --git a/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/AdvertisingTests.kt b/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/AdvertisingTests.kt
new file mode 100644
index 0000000..d98a44b
--- /dev/null
+++ b/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/AdvertisingTests.kt
@@ -0,0 +1,153 @@
+package com.bitmovin.analytics.conviva.testapp
+
+import android.os.Handler
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.bitmovin.analytics.conviva.ConvivaAnalyticsIntegration
+import com.bitmovin.analytics.conviva.ConvivaConfig
+import com.bitmovin.analytics.conviva.MetadataOverrides
+import com.bitmovin.analytics.conviva.testapp.framework.BITMOVIN_PLAYER_LICENSE_KEY
+import com.bitmovin.analytics.conviva.testapp.framework.CONVIVA_CUSTOMER_KEY
+import com.bitmovin.analytics.conviva.testapp.framework.CONVIVA_GATEWAY_URL
+import com.bitmovin.analytics.conviva.testapp.framework.Sources
+import com.bitmovin.analytics.conviva.testapp.framework.expectEvent
+import com.bitmovin.analytics.conviva.testapp.framework.postWaiting
+import com.bitmovin.player.api.PlaybackConfig
+import com.bitmovin.player.api.Player
+import com.bitmovin.player.api.PlayerConfig
+import com.bitmovin.player.api.advertising.AdItem
+import com.bitmovin.player.api.advertising.AdSource
+import com.bitmovin.player.api.advertising.AdSourceType
+import com.bitmovin.player.api.advertising.AdvertisingConfig
+import com.bitmovin.player.api.analytics.AnalyticsPlayerConfig
+import com.bitmovin.player.api.event.PlayerEvent
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * This test class does not verify any specific behavior, but rather can be used to validate the
+ * integration against the [Conviva Touchstone integration test tool](https://touchstone.conviva.com/).
+ */
+@RunWith(AndroidJUnit4::class)
+class AdvertisingTests {
+    /**
+     * Plays the first 5 seconds of a stream with a VMAP ad that includes a single pre-roll with a
+     * attached [ConvivaAnalyticsIntegration].
+     * Ad playback is paused and resumed to test for according events.
+     */
+    @Test
+    fun reports_ad_analytics_for_IMA_pre_roll_ad() {
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        val mainHandler = Handler(context.mainLooper)
+        val player = mainHandler.postWaiting {
+            val player = Player(
+                    context,
+                    PlayerConfig(
+                            key = BITMOVIN_PLAYER_LICENSE_KEY,
+                            advertisingConfig = AdvertisingConfig(
+                                    AdItem(AdSource(AdSourceType.Ima, Sources.Ads.VMAP_PREROLL_SINGLE_TAG)),
+                            ),
+                            playbackConfig = PlaybackConfig(
+                                    isAutoplayEnabled = true,
+                            ),
+                    ),
+                    analyticsConfig = AnalyticsPlayerConfig.Disabled,
+            )
+            val convivaAnalyticsIntegration = ConvivaAnalyticsIntegration(
+                    player,
+                    CONVIVA_CUSTOMER_KEY,
+                    context,
+                    ConvivaConfig().apply {
+                        isDebugLoggingEnabled = true
+                        gatewayUrl = CONVIVA_GATEWAY_URL
+                    },
+            )
+
+            convivaAnalyticsIntegration.updateContentMetadata(
+                    MetadataOverrides()
+                            .apply {
+                                applicationName = "Bitmovin Android Conviva integration example app"
+                                viewerId = "testViewerId"
+                            }
+            )
+            player
+        }
+
+        mainHandler.postWaiting { player.load(Sources.Dash.basic) }
+        player.expectEvent<PlayerEvent.TimeChanged> { it.time > 5.0 }
+
+        // pause player for a second and resume playback
+        mainHandler.postWaiting { player.pause() }
+        runBlocking { delay(1000) }
+        mainHandler.postWaiting { player.play() }
+
+        // wait for the ad break to finish and play main content for five more seconds
+        player.expectEvent<PlayerEvent.AdBreakFinished>()
+        player.expectEvent<PlayerEvent.TimeChanged> { it.time > 5.0 }
+
+        mainHandler.postWaiting { player.destroy() }
+        runBlocking { delay(1000) }
+    }
+
+    /**
+     * Plays a live stream with a VMAP ad that includes a pre-roll, mid-roll and post-roll ad with
+     * attached [ConvivaAnalyticsIntegration].
+     *
+     * The mid-roll ad is scheduled to play after 15 seconds and must show up in Conviva's Touchstone
+     * with the correct ad position `MIDROLL`.
+     */
+    @Test
+    fun reports_correct_ad_position_on_live_stream_with_vmap_mid_roll() {
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        val mainHandler = Handler(context.mainLooper)
+        val player = mainHandler.postWaiting {
+            val player = Player(
+                context,
+                PlayerConfig(
+                    key = BITMOVIN_PLAYER_LICENSE_KEY,
+                    advertisingConfig = AdvertisingConfig(
+                        AdItem(
+                            AdSource(
+                                AdSourceType.Ima,
+                                Sources.Ads.VMAP_PREROLL_MIDROLL_POSTROLL_TAG
+                            )
+                        ),
+                    ),
+                    playbackConfig = PlaybackConfig(
+                        isAutoplayEnabled = true,
+                    ),
+                ),
+                analyticsConfig = AnalyticsPlayerConfig.Disabled,
+            )
+            val convivaAnalyticsIntegration = ConvivaAnalyticsIntegration(
+                player,
+                CONVIVA_CUSTOMER_KEY,
+                context,
+                ConvivaConfig().apply {
+                    isDebugLoggingEnabled = true
+                    gatewayUrl = CONVIVA_GATEWAY_URL
+                },
+            )
+
+            convivaAnalyticsIntegration.updateContentMetadata(
+                MetadataOverrides()
+                    .apply {
+                        applicationName = "Bitmovin Android Conviva integration example app"
+                        viewerId = "testViewerId"
+                    }
+            )
+            player
+        }
+
+        mainHandler.postWaiting { player.load(Sources.Dash.basicLive) }
+
+        // mid-roll ad break is scheduled at 15 seconds, will play immediately in case of the DASH
+        // live stream due to absolute time stamps.
+        player.expectEvent<PlayerEvent.AdBreakStarted> {
+            it.adBreak!!.scheduleTime == 15.0
+        }
+        player.expectEvent<PlayerEvent.AdBreakFinished>()
+    }
+}
diff --git a/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/LatePlayerAttachingTest.kt b/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/LatePlayerAttachingTest.kt
new file mode 100644
index 0000000..e2b6f83
--- /dev/null
+++ b/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/LatePlayerAttachingTest.kt
@@ -0,0 +1,92 @@
+package com.bitmovin.analytics.conviva.testapp
+
+import android.os.Handler
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.bitmovin.analytics.conviva.ConvivaAnalyticsIntegration
+import com.bitmovin.analytics.conviva.ConvivaConfig
+import com.bitmovin.analytics.conviva.MetadataOverrides
+import com.bitmovin.analytics.conviva.testapp.framework.BITMOVIN_PLAYER_LICENSE_KEY
+import com.bitmovin.analytics.conviva.testapp.framework.CONVIVA_CUSTOMER_KEY
+import com.bitmovin.analytics.conviva.testapp.framework.CONVIVA_GATEWAY_URL
+import com.bitmovin.analytics.conviva.testapp.framework.Sources
+import com.bitmovin.analytics.conviva.testapp.framework.expectEvent
+import com.bitmovin.analytics.conviva.testapp.framework.postWaiting
+import com.bitmovin.player.api.PlaybackConfig
+import com.bitmovin.player.api.Player
+import com.bitmovin.player.api.PlayerConfig
+import com.bitmovin.player.api.advertising.AdItem
+import com.bitmovin.player.api.advertising.AdSource
+import com.bitmovin.player.api.advertising.AdSourceType
+import com.bitmovin.player.api.advertising.AdvertisingConfig
+import com.bitmovin.player.api.analytics.AnalyticsPlayerConfig
+import com.bitmovin.player.api.event.PlayerEvent
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * This test class does not verify any specific behavior, but rather can be used to validate the
+ * integration against the [Conviva Touchstone integration test tool](https://touchstone.conviva.com/).
+ */
+@RunWith(AndroidJUnit4::class)
+class LatePlayerAttachingTest {
+    /**
+     * Creates a tracking session and attaches the Player instance after the session has been initialized.
+     * The VST should be around 3 second in Touchstone.
+     */
+    @Test
+    fun includesTimeBetweenSessionInitializationAndSourceLoadingAsVST() {
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        val mainHandler = Handler(context.mainLooper)
+
+        val convivaAnalyticsIntegration = mainHandler.postWaiting {
+            val convivaAnalyticsIntegration = ConvivaAnalyticsIntegration(
+                CONVIVA_CUSTOMER_KEY,
+                context,
+                ConvivaConfig().apply {
+                    isDebugLoggingEnabled = true
+                    gatewayUrl = CONVIVA_GATEWAY_URL
+                },
+            )
+            convivaAnalyticsIntegration.updateContentMetadata(
+                MetadataOverrides()
+                    .apply {
+                        applicationName = "Bitmovin Android Conviva integration example app"
+                        viewerId = "testViewerId"
+                        assetName = "Asset Name"
+                    }
+            )
+            convivaAnalyticsIntegration.initializeSession()
+            convivaAnalyticsIntegration
+        }
+
+        runBlocking { delay(2000) }
+
+        val player = mainHandler.postWaiting {
+            val player = Player(
+                context,
+                PlayerConfig(
+                    key = BITMOVIN_PLAYER_LICENSE_KEY,
+                    playbackConfig = PlaybackConfig(
+                        isAutoplayEnabled = true,
+                    ),
+                ),
+                analyticsConfig = AnalyticsPlayerConfig.Disabled,
+            )
+            player
+        }
+
+        mainHandler.postWaiting { convivaAnalyticsIntegration.attachPlayer(player) }
+
+        runBlocking { delay(1000) }
+
+        mainHandler.postWaiting { player.load(Sources.Dash.basic) }
+
+        player.expectEvent<PlayerEvent.TimeChanged> { it.time > 5.0 }
+
+        mainHandler.postWaiting { player.destroy() }
+        runBlocking { delay(1000) }
+    }
+}
diff --git a/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/MetricReportingTests.kt b/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/MetricReportingTests.kt
new file mode 100644
index 0000000..d0da1b0
--- /dev/null
+++ b/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/MetricReportingTests.kt
@@ -0,0 +1,99 @@
+package com.bitmovin.analytics.conviva.testapp
+
+import android.os.Handler
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.bitmovin.analytics.conviva.ConvivaAnalyticsIntegration
+import com.bitmovin.analytics.conviva.ConvivaConfig
+import com.bitmovin.analytics.conviva.MetadataOverrides
+import com.bitmovin.analytics.conviva.testapp.framework.BITMOVIN_PLAYER_LICENSE_KEY
+import com.bitmovin.analytics.conviva.testapp.framework.CONVIVA_CUSTOMER_KEY
+import com.bitmovin.analytics.conviva.testapp.framework.CONVIVA_GATEWAY_URL
+import com.bitmovin.analytics.conviva.testapp.framework.Sources
+import com.bitmovin.analytics.conviva.testapp.framework.expectEvent
+import com.bitmovin.analytics.conviva.testapp.framework.postWaiting
+import com.bitmovin.player.api.PlaybackConfig
+import com.bitmovin.player.api.Player
+import com.bitmovin.player.api.PlayerConfig
+import com.bitmovin.player.api.analytics.AnalyticsPlayerConfig
+import com.bitmovin.player.api.event.PlayerEvent
+import com.bitmovin.player.api.network.HttpRequestType
+import com.bitmovin.player.api.network.NetworkConfig
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.util.concurrent.CompletableFuture
+
+/**
+ * This test class does not verify any specific behavior, but rather can be used to validate the
+ * integration against the [Conviva Touchstone integration test tool](https://touchstone.conviva.com/).
+ */
+@RunWith(AndroidJUnit4::class)
+class MetricReportingTests {
+    /**
+     * Plays the first 5 seconds of a stream with a attached [ConvivaAnalyticsIntegration].
+     * Additionally injects average bitrate to the HLS manifest in order to report it.
+     */
+    @Test
+    fun reports_average_bitrate_and_peak_bitrate() {
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        val mainHandler = Handler(context.mainLooper)
+        val player = mainHandler.postWaiting {
+            val player = Player(
+                context,
+                PlayerConfig(
+                    key = BITMOVIN_PLAYER_LICENSE_KEY,
+                    playbackConfig = PlaybackConfig(
+                        isAutoplayEnabled = true,
+                    ),
+                    networkConfig = NetworkConfig(preprocessHttpResponseCallback = { type, response ->
+                        if (type != HttpRequestType.ManifestHlsMaster) {
+                            return@NetworkConfig null
+                        }
+                        val body = response.body.decodeToString()
+
+                        val regex = "BANDWIDTH=([0-9]+),".toRegex()
+                        val newBody = regex.replace(body) {
+                            val bandwidth = it.groups[1]!!.value.toInt()
+                            "BANDWIDTH=${bandwidth},AVERAGE-BANDWIDTH=${bandwidth - 100_000},"
+                        }
+
+                        CompletableFuture.completedFuture(response.copy(body = newBody.encodeToByteArray()))
+                    })
+                ),
+                analyticsConfig = AnalyticsPlayerConfig.Disabled,
+            )
+            val convivaAnalyticsIntegration = ConvivaAnalyticsIntegration(
+                player,
+                CONVIVA_CUSTOMER_KEY,
+                context,
+                ConvivaConfig().apply {
+                    isDebugLoggingEnabled = true
+                    gatewayUrl = CONVIVA_GATEWAY_URL
+                },
+            )
+
+            convivaAnalyticsIntegration.updateContentMetadata(
+                MetadataOverrides()
+                    .apply {
+                        applicationName = "Bitmovin Android Conviva integration example app"
+                        viewerId = "testViewerId"
+                    }
+            )
+            player
+        }
+
+        mainHandler.postWaiting { player.load(Sources.Hls.basic) }
+        player.expectEvent<PlayerEvent.TimeChanged> { it.time > 5.0 }
+
+        // pause player for a second and resume playback
+        mainHandler.postWaiting { player.pause() }
+        runBlocking { delay(1000) }
+        mainHandler.postWaiting { player.play() }
+        runBlocking { delay(1000) }
+
+        mainHandler.postWaiting { player.destroy() }
+        runBlocking { delay(1000) }
+    }
+}
diff --git a/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/SsaiTests.kt b/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/SsaiTests.kt
new file mode 100644
index 0000000..50b94a5
--- /dev/null
+++ b/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/SsaiTests.kt
@@ -0,0 +1,118 @@
+package com.bitmovin.analytics.conviva.testapp
+
+import android.os.Handler
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.bitmovin.analytics.conviva.ConvivaAnalyticsIntegration
+import com.bitmovin.analytics.conviva.ConvivaConfig
+import com.bitmovin.analytics.conviva.MetadataOverrides
+import com.bitmovin.analytics.conviva.ssai.SsaiApi
+import com.bitmovin.analytics.conviva.testapp.framework.BITMOVIN_PLAYER_LICENSE_KEY
+import com.bitmovin.analytics.conviva.testapp.framework.CONVIVA_CUSTOMER_KEY
+import com.bitmovin.analytics.conviva.testapp.framework.CONVIVA_GATEWAY_URL
+import com.bitmovin.analytics.conviva.testapp.framework.Sources
+import com.bitmovin.analytics.conviva.testapp.framework.expectEvent
+import com.bitmovin.analytics.conviva.testapp.framework.postWaiting
+import com.bitmovin.player.api.PlaybackConfig
+import com.bitmovin.player.api.Player
+import com.bitmovin.player.api.PlayerConfig
+import com.bitmovin.player.api.analytics.AnalyticsPlayerConfig
+import com.bitmovin.player.api.event.PlayerEvent
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import org.junit.Test
+import org.junit.runner.RunWith
+
+
+/**
+ * This test class does not verify any specific behavior, but rather can be used to validate the
+ * integration against the [Conviva Touchstone integration test tool](https://touchstone.conviva.com/).
+ */
+@RunWith(AndroidJUnit4::class)
+class SsaiTests {
+    /**
+     * Plays a vod stream and fakes a SSAI ad break with a single 5 seconds ad and a  1 seconds slate.
+     */
+    @Test
+    fun reports_ad_analytics_for_mid_roll_ad() {
+        val adStart = 5.0
+        val adDuration = 5.0
+        val slateStart = adStart + adDuration
+        val slateDuration = 1.0
+
+
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        val mainHandler = Handler(context.mainLooper)
+        val player = mainHandler.postWaiting {
+            Player(
+                    context,
+                    PlayerConfig(
+                            key = BITMOVIN_PLAYER_LICENSE_KEY,
+                            playbackConfig = PlaybackConfig(
+                                    isAutoplayEnabled = true,
+                            ),
+                    ),
+                    analyticsConfig = AnalyticsPlayerConfig.Disabled,
+            )
+        }
+
+        val integration = mainHandler.postWaiting {
+            val convivaAnalyticsIntegration = ConvivaAnalyticsIntegration(
+                    player,
+                    CONVIVA_CUSTOMER_KEY,
+                    context,
+                    ConvivaConfig().apply {
+                        isDebugLoggingEnabled = true
+                        gatewayUrl = CONVIVA_GATEWAY_URL
+                    },
+            )
+
+            convivaAnalyticsIntegration.updateContentMetadata(
+                    MetadataOverrides()
+                            .apply {
+                                applicationName = "Bitmovin Android Conviva integration example app"
+                                viewerId = "testViewerId"
+                            }
+            )
+            convivaAnalyticsIntegration
+        }
+
+        mainHandler.postWaiting { player.load(Sources.Dash.basic) }
+        player.expectEvent<PlayerEvent.TimeChanged> { it.time > adStart } // play main content until ad start
+
+        // fake ad break
+        mainHandler.postWaiting {
+            integration.ssai.reportAdBreakStarted()
+            integration.ssai.reportAdStarted(SsaiApi.AdInfo().apply {
+                duration = adDuration
+                isSlate = false
+                id = "testAdId"
+                title = "testAdTitle"
+            })
+        }
+
+        player.expectEvent<PlayerEvent.TimeChanged> { it.time > adStart + adDuration } // wait unitl ad is over
+
+
+        mainHandler.postWaiting {
+            integration.ssai.reportAdFinished()
+            integration.ssai.reportAdStarted(
+                    SsaiApi.AdInfo().apply {
+                        duration = slateDuration
+                        isSlate = true
+                        title = "testSlate"
+                    }
+            )
+        }
+
+        player.expectEvent<PlayerEvent.TimeChanged> { it.time > slateStart + slateDuration } // wait for five more seconds of playback
+
+        mainHandler.postWaiting {
+            integration.ssai.reportAdFinished()
+            integration.ssai.reportAdBreakFinished()
+        }
+
+        mainHandler.postWaiting { player.destroy() }
+        runBlocking { delay(1000) }
+    }
+}
diff --git a/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/TestBase.kt b/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/TestBase.kt
index d426cb6..be88a6d 100644
--- a/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/TestBase.kt
+++ b/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/TestBase.kt
@@ -8,7 +8,9 @@ import androidx.test.core.app.ApplicationProvider
 import com.bitmovin.analytics.conviva.ConvivaAnalyticsIntegration
 import com.bitmovin.analytics.conviva.ConvivaConfig
 import com.bitmovin.analytics.conviva.MetadataOverrides
+import com.bitmovin.analytics.conviva.testapp.framework.Sources
 import com.bitmovin.player.api.source.Source
+import com.bitmovin.player.api.source.SourceBuilder
 import com.bitmovin.player.api.source.SourceConfig
 import com.bitmovin.player.api.source.SourceType
 import com.conviva.sdk.ConvivaAnalytics
@@ -23,7 +25,6 @@ open class TestBase {
     lateinit var convivaConfig: ConvivaConfig
     var convivaAnalyticsIntegration: ConvivaAnalyticsIntegration? = null
     var videoAnalyticsMock: ConvivaVideoAnalytics? = null
-    var convivaAnalyticsMock: ConvivaAnalytics? = null
     lateinit var activityScenario: ActivityScenario<MainActivity>
 
     val CUSTOM_EVENT_NAME = "CUSTOM_APPLICATION_EVENT"
@@ -32,11 +33,17 @@ open class TestBase {
     ) as HashMap<String, String>
     val CUSTOM_ERROR_MESSAGE = "CUSTOM_ERROR_MESSAGE"
 
-    val DEFAULT_DASH_VOD_SOURCE = Source.create(SourceConfig("https://bitmovin-a.akamaihd.net/content/MI201109210084_1/mpds/f08e80da-bf1d-4e3d-8899-f0f6155f6efa.mpd", SourceType.Dash))
+    val DEFAULT_DASH_VOD_SOURCE = SourceBuilder(Sources.Dash.basic).build()
     val DEFAULT_DASH_VOD_SOURCE_DURATION = 210
-    val DEFAULT_DASH_LIVE_SOURCE = Source.create(SourceConfig("https://livesim.dashif.org/livesim/testpic_2s/Manifest.mpd", SourceType.Dash))
+    val DEFAULT_DASH_LIVE_SOURCE = Source.create(
+        SourceConfig(
+            "https://livesim.dashif.org/livesim/testpic_2s/Manifest.mpd",
+            SourceType.Dash
+        )
+    )
     val DEFAULT_DASH_LIVE_SOURCE_DURATION = 0
-    val INVALID_DASH_VOD_SOURCE = Source.create(SourceConfig("https://bitmovin.com", SourceType.Dash))
+    val INVALID_DASH_VOD_SOURCE =
+        Source.create(SourceConfig("https://bitmovin.com", SourceType.Dash))
 
     val PLAYER_TYPE = "Bitmovin Player Android"
     val TIMEOUT = 4000
@@ -72,22 +79,28 @@ open class TestBase {
         mockConvivaAnalyticsObject()
     }
 
-    fun tearDownMocks () {
+    fun tearDownMocks() {
         videoAnalyticsMock?.let { unmockkObject(it) }
     }
 
-    fun  createConvivaAnalyticsObject(activity: MainActivity) : ConvivaAnalyticsIntegration {
+    fun createConvivaAnalyticsObject(activity: MainActivity): ConvivaAnalyticsIntegration {
         // Setup mocks and create ConvivaAnalytics using mock objects
         ConvivaAnalytics.init(activity.applicationContext, "test")
         setupMocks(activity.applicationContext)
-        return spyk(ConvivaAnalyticsIntegration(
+        return spyk(
+            ConvivaAnalyticsIntegration(
                 activity.bitmovinPlayer,
                 "test",
                 activity.applicationContext,
-                convivaConfig, videoAnalyticsMock))
+                convivaConfig,
+                videoAnalyticsMock,
+                null,
+                null
+            )
+        )
     }
 
-    fun defaultMetadataOverrides() : MetadataOverrides {
+    fun defaultMetadataOverrides(): MetadataOverrides {
         val metadata = MetadataOverrides()
         metadata.applicationName = "Bitmovin Android Conviva test app"
         metadata.viewerId = "awesomeViewerId"
@@ -100,7 +113,7 @@ open class TestBase {
         streamType: ConvivaSdkConstants.StreamType? = null,
         duration: Int? = null,
         customTags: Map<String, String>? = null
-    ) : MetadataOverrides {
+    ): MetadataOverrides {
         val metadata = MetadataOverrides()
         metadata.applicationName = "Bitmovin Android Conviva test app"
         metadata.viewerId = "awesomeViewerId"
@@ -125,7 +138,7 @@ open class TestBase {
         duration: Int,
         overrideMetadata: MetadataOverrides,
         overrideCustom: Boolean = false
-    ) : MutableMap<String, Any> {
+    ): MutableMap<String, Any> {
         val contentInfo = mutableMapOf<String, Any>()
         contentInfo[ConvivaSdkConstants.PLAYER_NAME] = overrideMetadata.applicationName
         contentInfo[ConvivaSdkConstants.VIEWER_ID] = overrideMetadata.viewerId
@@ -133,43 +146,50 @@ open class TestBase {
         contentInfo[ConvivaSdkConstants.ENCODED_FRAMERATE] = -1
         contentInfo[ConvivaSdkConstants.IS_OFFLINE_PLAYBACK] = false
         if (overrideCustom) {
-            contentInfo[ConvivaSdkConstants.STREAM_URL] = overrideMetadata.streamUrl ?: source.config.url
+            contentInfo[ConvivaSdkConstants.STREAM_URL] =
+                overrideMetadata.streamUrl ?: source.config.url
             val streamTypeLocal = overrideMetadata.streamType ?: streamType
-            contentInfo[ConvivaSdkConstants.IS_LIVE] = streamTypeLocal == ConvivaSdkConstants.StreamType.LIVE;
+            contentInfo[ConvivaSdkConstants.IS_LIVE] =
+                streamTypeLocal == ConvivaSdkConstants.StreamType.LIVE;
             contentInfo[ConvivaSdkConstants.DURATION] = overrideMetadata.duration ?: duration
             overrideMetadata.custom.forEach { (s: String, s2: String) ->
                 contentInfo[s] = s2
             }
-            contentInfo["streamType"] = overrideMetadata.custom["streamType"] ?: source.config.type.toString()
-            contentInfo["integrationVersion"] = overrideMetadata.custom["integrationVersion"] ?: com.bitmovin.analytics.conviva.BuildConfig.VERSION_NAME
+            contentInfo["streamType"] =
+                overrideMetadata.custom["streamType"] ?: source.config.type.toString()
+            contentInfo["integrationVersion"] = overrideMetadata.custom["integrationVersion"]
+                ?: com.bitmovin.analytics.conviva.BuildConfig.VERSION_NAME
         } else {
             contentInfo[ConvivaSdkConstants.STREAM_URL] = source.config.url
-            contentInfo[ConvivaSdkConstants.IS_LIVE] = streamType == ConvivaSdkConstants.StreamType.LIVE
+            contentInfo[ConvivaSdkConstants.IS_LIVE] =
+                streamType == ConvivaSdkConstants.StreamType.LIVE
             contentInfo[ConvivaSdkConstants.DURATION] = duration
             contentInfo["streamType"] = source.config.type.toString()
-            contentInfo["integrationVersion"] = com.bitmovin.analytics.conviva.BuildConfig.VERSION_NAME
+            contentInfo["integrationVersion"] =
+                com.bitmovin.analytics.conviva.BuildConfig.VERSION_NAME
         }
         return contentInfo
     }
 
     // TODO: All references to ContentMetadata are obsolete and we should be using Map<String, String> instead
-    fun MockKMatcherScope.metadataEq(expectedMetadata: MetadataOverrides) = match<MetadataOverrides>  {
-        it.assetName == expectedMetadata.assetName &&
-        it.applicationName == expectedMetadata.applicationName &&
-        it.viewerId == expectedMetadata.viewerId &&
-        it.streamType == expectedMetadata.streamType &&
-        it.streamUrl == expectedMetadata.streamUrl &&
-        it.duration == expectedMetadata.duration &&
-        it.encodedFrameRate == expectedMetadata.encodedFrameRate &&
-        it.custom.equals(expectedMetadata.custom)
-    }
+    fun MockKMatcherScope.metadataEq(expectedMetadata: MetadataOverrides) =
+        match<MetadataOverrides> {
+            it.assetName == expectedMetadata.assetName &&
+                    it.applicationName == expectedMetadata.applicationName &&
+                    it.viewerId == expectedMetadata.viewerId &&
+                    it.streamType == expectedMetadata.streamType &&
+                    it.streamUrl == expectedMetadata.streamUrl &&
+                    it.duration == expectedMetadata.duration &&
+                    it.encodedFrameRate == expectedMetadata.encodedFrameRate &&
+                    it.custom.equals(expectedMetadata.custom)
+        }
 
 
     fun setupPlayerActivityForTest(
         autoPlay: Boolean,
         metadataOverrides: MetadataOverrides,
         adTag: String = ""
-    ) : ActivityScenario<MainActivity> {
+    ): ActivityScenario<MainActivity> {
         val launchIntent = Intent(
             ApplicationProvider.getApplicationContext(),
             MainActivity::class.java
@@ -207,13 +227,17 @@ open class TestBase {
     }
 
     // Implicit session tests do not actually initialize the session until play starts, in the new SDK
-    fun verifySessionInitialization(activityScenario: ActivityScenario<MainActivity>, metadata: MetadataOverrides?, implicit: Boolean = false) {
+    fun verifySessionInitialization(
+        activityScenario: ActivityScenario<MainActivity>,
+        metadata: MetadataOverrides?,
+        implicit: Boolean = false
+    ) {
         activityScenario.onActivity { _: MainActivity ->
             verifyOrder {
-                if(metadata != null) {
+                if (metadata != null) {
                     convivaAnalyticsIntegration?.updateContentMetadata(metadata)
                 }
-                if(!implicit) {
+                if (!implicit) {
                     convivaAnalyticsIntegration?.initializeSession()
 
                     if (metadata != null) {
@@ -240,7 +264,10 @@ open class TestBase {
     fun verifyPlaying(activityScenario: ActivityScenario<MainActivity>) {
         activityScenario.onActivity { activity: MainActivity ->
             verify {
-                videoAnalyticsMock?.reportPlaybackMetric(ConvivaSdkConstants.PLAYBACK.PLAYER_STATE, ConvivaSdkConstants.PlayerState.PLAYING);
+                videoAnalyticsMock?.reportPlaybackMetric(
+                    ConvivaSdkConstants.PLAYBACK.PLAYER_STATE,
+                    ConvivaSdkConstants.PlayerState.PLAYING
+                );
             }
         }
     }
@@ -268,18 +295,23 @@ open class TestBase {
                 metadata.assetName = rawMetadata[ConvivaSdkConstants.ASSET_NAME] as String?
                 metadata.applicationName = rawMetadata[ConvivaSdkConstants.PLAYER_NAME] as String?
                 metadata.viewerId = rawMetadata[ConvivaSdkConstants.VIEWER_ID] as String?
-                metadata.streamType = if (rawMetadata[ConvivaSdkConstants.IS_LIVE] as Boolean) ConvivaSdkConstants.StreamType.LIVE else ConvivaSdkConstants.StreamType.VOD
+                metadata.streamType =
+                    if (rawMetadata[ConvivaSdkConstants.IS_LIVE] as Boolean) ConvivaSdkConstants.StreamType.LIVE else ConvivaSdkConstants.StreamType.VOD
                 metadata.streamUrl = rawMetadata[ConvivaSdkConstants.STREAM_URL] as String?
                 metadata.duration = rawMetadata[ConvivaSdkConstants.DURATION] as Int?
-                metadata.encodedFrameRate = rawMetadata[ConvivaSdkConstants.ENCODED_FRAMERATE] as Int?
+                metadata.encodedFrameRate =
+                    rawMetadata[ConvivaSdkConstants.ENCODED_FRAMERATE] as Int?
 
-                convivaAnalyticsIntegration?.updateContentMetadata(metadataEq ( metadata ))
+                convivaAnalyticsIntegration?.updateContentMetadata(metadataEq(metadata))
             }
 
 
 
             verify(atLeast = 1) {
-                videoAnalyticsMock?.reportPlaybackMetric(ConvivaSdkConstants.PLAYBACK.PLAYER_STATE, ConvivaSdkConstants.PlayerState.PLAYING);
+                videoAnalyticsMock?.reportPlaybackMetric(
+                    ConvivaSdkConstants.PLAYBACK.PLAYER_STATE,
+                    ConvivaSdkConstants.PlayerState.PLAYING
+                );
             }
         }
     }
diff --git a/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/WarningTests.kt b/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/WarningTests.kt
new file mode 100644
index 0000000..47cbb69
--- /dev/null
+++ b/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/WarningTests.kt
@@ -0,0 +1,84 @@
+package com.bitmovin.analytics.conviva.testapp
+
+import android.os.Handler
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.bitmovin.analytics.conviva.ConvivaAnalyticsIntegration
+import com.bitmovin.analytics.conviva.ConvivaConfig
+import com.bitmovin.analytics.conviva.MetadataOverrides
+import com.bitmovin.analytics.conviva.testapp.framework.BITMOVIN_PLAYER_LICENSE_KEY
+import com.bitmovin.analytics.conviva.testapp.framework.CONVIVA_CUSTOMER_KEY
+import com.bitmovin.analytics.conviva.testapp.framework.CONVIVA_GATEWAY_URL
+import com.bitmovin.analytics.conviva.testapp.framework.Sources
+import com.bitmovin.analytics.conviva.testapp.framework.callAndExpectEvent
+import com.bitmovin.analytics.conviva.testapp.framework.expectEvent
+import com.bitmovin.analytics.conviva.testapp.framework.postWaiting
+import com.bitmovin.player.api.PlaybackConfig
+import com.bitmovin.player.api.Player
+import com.bitmovin.player.api.PlayerConfig
+import com.bitmovin.player.api.analytics.AnalyticsPlayerConfig
+import com.bitmovin.player.api.event.PlayerEvent
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * This test class does not verify any specific behavior, but rather can be used to validate the
+ * integration against the [Conviva Touchstone integration test tool](https://touchstone.conviva.com/).
+ */
+@RunWith(AndroidJUnit4::class)
+class WarningTests {
+    /**
+     * Triggers a warning outside of the active conviva session. No integration error must be
+     * shown in Touchstone.
+     */
+    @Test
+    fun warning_outside_of_active_conviva_session_does_not_cause_integration_error() {
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        val mainHandler = Handler(context.mainLooper)
+        val player = mainHandler.postWaiting {
+            Player(
+                    context,
+                    PlayerConfig(
+                            key = BITMOVIN_PLAYER_LICENSE_KEY,
+                            playbackConfig = PlaybackConfig(
+                                    isAutoplayEnabled = true,
+                            ),
+                    ),
+                    analyticsConfig = AnalyticsPlayerConfig.Disabled,
+            )
+        }
+        mainHandler.postWaiting {
+            val conviva = ConvivaAnalyticsIntegration(
+                    player,
+                    CONVIVA_CUSTOMER_KEY,
+                    context,
+                    ConvivaConfig().apply {
+                        isDebugLoggingEnabled = true
+                        gatewayUrl = CONVIVA_GATEWAY_URL
+                    },
+            )
+            conviva.updateContentMetadata(
+                    MetadataOverrides().apply {
+                        applicationName = "Bitmovin Android Conviva integration test app"
+                        viewerId = "testViewerId"
+                        assetName = "warning_outside_of_active_conviva_session_does_not_cause_integration_error"
+                    }
+            )
+        }
+
+        mainHandler.postWaiting {
+            player.load(Sources.Dash.basic)
+        }
+        player.expectEvent<PlayerEvent.TimeChanged> { it.time > 10.0 }
+        mainHandler.postWaiting {
+            player.unload() // Unloading the player ends the active conviva session
+        }
+        runBlocking { delay(500) } // Give conviva some time to end the session
+        player.callAndExpectEvent<PlayerEvent.Warning>(block = {
+            player.play() // Calling "play" outside of an active playback session triggers a warning
+        })
+        runBlocking { delay(500) } // Give Conviva some time to report the event
+    }
+}
diff --git a/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/framework/Sources.kt b/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/framework/Sources.kt
new file mode 100644
index 0000000..f47814c
--- /dev/null
+++ b/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/framework/Sources.kt
@@ -0,0 +1,36 @@
+package com.bitmovin.analytics.conviva.testapp.framework
+
+import com.bitmovin.player.api.source.SourceConfig
+import com.bitmovin.player.api.source.SourceType
+
+object Sources {
+    object Ads {
+        const val VMAP_PREROLL_SINGLE_TAG = "https://pubads.g.doubleclick.net/gampad/ads?sz=640x480&iu=/124319096/external/ad_rule_samples&ciu_szs=300x250&ad_rule=1&impl=s&gdfp_req=1&env=vp&output=vmap&unviewed_position_start=1&cust_params=deployment%3Ddevsite%26sample_ar%3Dpreonly&cmsid=496&vid=short_onecue&correlator="
+
+        const val VMAP_PREROLL_MIDROLL_POSTROLL_TAG = "https://pubads.g.doubleclick.net/gampad/ads?iu=/21775744923/external/vmap_ad_samples&sz=640x480&cust_params=sample_ar%3Dpremidpost&ciu_szs=300x250&gdfp_req=1&ad_rule=1&output=vmap&unviewed_position_start=1&env=vp&impl=s&cmsid=496&vid=short_onecue&correlator="
+
+        const val VAST_SINGLE_LINEAR_INLINE = "https://pubads.g.doubleclick.net/gampad/ads?iu=/21775744923/external/single_ad_samples&sz=640x480&cust_params=sample_ct%3Dlinear&ciu_szs=300x250%2C728x90&gdfp_req=1&output=vast&unviewed_position_start=1&env=vp&impl=s&correlator="
+    }
+
+    object Dash {
+        val basic = SourceConfig(
+                url = "https://bitmovin-a.akamaihd.net/content/MI201109210084_1/mpds/f08e80da-bf1d-4e3d-8899-f0f6155f6efa.mpd",
+                type = SourceType.Dash,
+                title = "Art of Motion Test Stream",
+        )
+
+        val basicLive = SourceConfig(
+                url = "https://livesim.dashif.org/livesim2/testpic_2s/Manifest.mpd",
+                type = SourceType.Dash,
+                title = "DASH livesim Live Stream",
+        )
+    }
+
+    object Hls {
+        val basic = SourceConfig(
+            url = "https://bitmovin-a.akamaihd.net/content/MI201109210084_1/m3u8s/f08e80da-bf1d-4e3d-8899-f0f6155f6efa.m3u8",
+            type = SourceType.Hls,
+            title = "Art of Motion Test Stream",
+        )
+    }
+}
diff --git a/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/framework/TestingFramework.kt b/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/framework/TestingFramework.kt
new file mode 100644
index 0000000..feffb62
--- /dev/null
+++ b/ConvivaTestApp/src/androidTest/java/com/bitmovin/analytics/conviva/testapp/framework/TestingFramework.kt
@@ -0,0 +1,64 @@
+package com.bitmovin.analytics.conviva.testapp.framework
+
+import android.os.Handler
+import com.bitmovin.player.api.Player
+import com.bitmovin.player.api.event.Event
+import com.bitmovin.player.api.event.EventEmitter
+import com.bitmovin.player.api.event.on
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
+const val BITMOVIN_PLAYER_LICENSE_KEY = "YOUR_LICENSE_KEY"
+const val CONVIVA_CUSTOMER_KEY = "YOUR-CUSTOMER-KEY"
+const val CONVIVA_GATEWAY_URL = "YOUR-GATEWAY-URL"
+
+
+/**
+ * Subscribes to an [Event] on the [Player] and suspends until the event is emitted.
+ * Optionally a [condition] can be provided to filter the emitted events.
+ */
+inline fun <reified T : Event> EventEmitter<Event>.expectEvent(
+        crossinline condition: (T) -> Boolean = { true }
+) = runBlocking {
+    suspendCoroutine { continuation ->
+        lateinit var action: ((T) -> Unit)
+        action = {
+            if (condition(it)) {
+                off(action)
+                continuation.resume(Unit)
+            }
+        }
+        on<T>(action)
+    }
+}
+
+/**
+ * Same as  [expectEvent] except that [block] is executed once the event listener is attached.
+ */
+inline fun <reified T : Event> EventEmitter<Event>.callAndExpectEvent(
+        crossinline block: suspend () -> Unit = {},
+        crossinline condition: (T) -> Boolean = { true }
+) = runBlocking {
+    launch { block() }
+    suspendCoroutine { continuation ->
+        lateinit var action: ((T) -> Unit)
+        action = {
+            if (condition(it)) {
+                off(action)
+                continuation.resume(Unit)
+            }
+        }
+        on<T>(action)
+    }
+}
+
+/**
+ * Posts a [block] of code to the main thread and suspends until it is executed.
+ */
+inline fun <T> Handler.postWaiting(crossinline block: () -> T) = runBlocking {
+    suspendCoroutine { continuation ->
+        post { continuation.resume(block()) }
+    }
+}
diff --git a/README.md b/README.md
index a323a56..3667d18 100644
--- a/README.md
+++ b/README.md
@@ -46,8 +46,8 @@ allprojects {
 And these lines to your main project
 ```
 dependencies {
-  implementation 'com.conviva.sdk:conviva-core-sdk:4.0.20' // <-- conviva sdk
-  implementation 'com.bitmovin.analytics:conviva:2.2.0'
+  implementation 'com.conviva.sdk:conviva-core-sdk:4.0.39' // <-- conviva sdk
+  implementation 'com.bitmovin.analytics:conviva:2.7.2'
 }
 ```
 
@@ -65,13 +65,11 @@ For more information about permissions and collected network types please look a
 
 The following example create a ConvivaAnalyticsIntegration object and attaches at Bitmovin Native SDK to it
 
-#### Basic Conviva Reporting
+### Basic Conviva Reporting
 
 ```java
-// Create your ConvivaConfiguration object
-ConvivaConfiguration convivaConfig = new ConvivaConfig(
-    "ConvivaExample_BitmovinPlayer",
-    "ViewerId1");
+// Create your ConvivaConfig object
+ConvivaConfig convivaConfig = new ConvivaConfig();
 
 // Create ConvivaAnalyticsIntegration
 convivaAnalyticsIntegration = new ConvivaAnalyticsIntegration(bitmovinPlayer, "YOUR-CUSTOMER-KEY", getApplicationContext(), convivaConfig);
@@ -85,25 +83,29 @@ Source source = Source.create(sourceConfig);
 bitmovinPlayer.load(source);
 ```
 
-#### Optional Configuration Parameters
+### Optional Configuration Parameters
 ```java
-
+convivaConfig.setGatewayUrl("YOUR_DEBUG_GATEWAY_URL");
 convivaConfig.setDebugLoggingEnabled(true);
-convivaConfig.setCustomData(customMapOfKeyValuePairs);
 
 ```
 
-#### Content Metadata handling
+### Content Metadata handling
 
-If you want to override some content metadata attributes you can do so by adding the following:
+If you want to override some content metadata attributes or track additional custom or standard tags you can do so by adding the following:
 
 ```java
 MetadataOverrides metadata = new MetadataOverrides();
 metadata.setApplicationName("Bitmovin Android Conviva integration example app");
 metadata.setViewerId("awesomeViewerId");
-Map<String, String> customInternTags = new HashMap<>();
-customInternTags.put("contentType", "Episode");
-metadata.setCustom(customInternTags);
+
+Map<String, Object> standardTags = new HashMap<>();
+standardTags.put("c3.cm.contentType", "VOD");
+metadata.setAdditionalStandardTags(standardTags);
+
+Map<String, String> customTags = new HashMap<>();
+customTags.put("custom_tag", "value");
+metadata.setCustom(customTags);
 
 // …
 // Initialize ConvivaAnalyticsIntegration
@@ -114,7 +116,7 @@ convivaAnalyticsIntegration.updateContentMetadata(metadata);
 
 Those values will be cleaned up after the session is closed.
 
-#### Consecutive playback
+### Consecutive playback
 	
 If you want to use the same player instance for multiple playback, just load a new source with player.load(…). The integration will close the active session.
 	
@@ -122,7 +124,7 @@ If you want to use the same player instance for multiple playback, just load a n
 player.load(…);
 ```
 
-#### Background handling
+### Background handling
 
 If your app stops playback when entering background conviva suggests to end the active session. Since the integration can't know if your app supports background playback this can't be done automatically.
 
@@ -131,7 +133,73 @@ A session can be ended using following method call:
 `convivaAnalyticsIntegration.endSession()`
 Since the `BitmovinPlayer` automatically pauses the video if no background playback is configured the session creation after the app is in foreground again is handled automatically.
 
-#### Clean up
+### Server Side Ad Tracking
+
+In order to track server side ads you can use the functions provided in `ConvivaAnalyticsIntegration.getSsai()`. The following example shows basic server side ad tracking:
+```java
+SsaiApi ssai = convivaAnalyticsIntegration.getSsai();
+
+ssai.reportAdBreakStarted();
+
+SsaiApi.AdInfo adInfo = new SsaiApi.AdInfo();
+adInfo.setPosition(AdPosition.PREROLL);
+adInfo.setTitle("My ad title");
+adInfo.setDuration(30);
+ssai.reportAdStarted(adInfo);
+
+...
+
+ssai.reportAdFinished();
+ssai.reportAdBreakFinished();
+```
+
+In addition to the metadata provided in the `AdInfo` object at ad start, the following metadata will be auto collected from the main content metadata:
+- ConvivaSdkConstants.STREAM_URL
+- ConvivaSdkConstants.ASSET_NAME
+- ConvivaSdkConstants.IS_LIVE
+- ConvivaSdkConstants.DEFAULT_RESOURCE 
+- ConvivaSdkConstants.ENCODED_FRAMERATE
+- ConvivaSdkConstants.VIEWER_ID
+- ConvivaSdkConstants.PLAYER_NAME
+- streamType
+- integrationVersion
+
+Metadata in the `AdInfo` overwrites all auto collected metadata.
+
+### External VST tracking
+
+If your app needs additional setup steps which should be included in VST tracking, such as DRM token generation, before the `Player` instance can be initialized,
+the `ConvivaAnalyticsIntegration` can be initialized without a `Player` instance. Once the `Player` instance is created it can be attached.
+
+1. Create the `ConvivaAnalyticsIntegration` instance with your `customerKey` and configuration.
+
+```java
+ConvivaAnalyticsIntegration convivaAnalyticsIntegration = new ConvivaAnalyticsIntegration(
+    customerKey,
+    getApplicationContext(),
+    convivaConfig
+);
+```
+
+2. Conviva requires that the `assetName` is set at session initialization. Therefore ensure that you provide using the `MetadataOverrides` **before** initializing the tracking session.
+
+```java
+MetadataOverrides metadata = new MetadataOverrides();
+metadata.setAssetName("Your Asset Name");
+convivaAnalyticsIntegration.updateContentMetadata(metadata);
+
+// Initialize tracking session
+convivaAnalyticsIntegration.initializeSession();
+```
+
+3. Once your `Player` instance is ready attach it to the `ConvivaAnalyticsIntegration` instance.
+
+```java
+// ... Additional setup steps
+convivaAnalyticsIntegration.attachPlayer(player);
+``` 
+
+### Clean up
 
 At end of app instance lifecycle, the convivaAnalyticsIntegration should be released:
 
diff --git a/build.gradle b/build.gradle
index 9933c45..3022578 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,15 +1,15 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 
 buildscript {
-    ext.kotlin_version = "1.7.0"
+    ext.kotlin_version = "1.9.23"
     repositories {
         mavenCentral()
         google()
     }
     dependencies {
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath 'com.android.tools.build:gradle:7.4.2'
-        classpath "org.jfrog.buildinfo:build-info-extractor-gradle:4.24.2"
+        classpath 'com.android.tools.build:gradle:8.2.2'
+        classpath "org.jfrog.buildinfo:build-info-extractor-gradle:4.33.1"
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
@@ -17,9 +17,9 @@ buildscript {
 }
 
 ext {
-    minSdkVersion = 16
-    targetSdkVersion = 33
-    compileSdkVersion = 33
+    minSdkVersion = 19
+    targetSdkVersion = 34
+    compileSdkVersion = 34
 }
 
 // Load dependencies
diff --git a/conviva/build.gradle b/conviva/build.gradle
index a135574..8861f34 100644
--- a/conviva/build.gradle
+++ b/conviva/build.gradle
@@ -1,13 +1,15 @@
 apply plugin: 'com.android.library'
 apply plugin: 'com.jfrog.artifactory'
 apply plugin: 'maven-publish'
+apply plugin: 'kotlin-android'
 apply from: "../bitmovinpropertiesloader.gradle"
 
 def packageName = 'com.bitmovin.analytics'
-def libraryVersion = '2.2.0'
+def libraryVersion = '2.7.2'
 
 android {
-    compileSdkVersion rootProject.compileSdkVersion
+    namespace 'com.bitmovin.analytics.conviva'
+    compileSdk rootProject.compileSdkVersion
 
     defaultConfig {
         minSdkVersion rootProject.minSdkVersion
@@ -27,45 +29,50 @@ android {
         sourceCompatibility JavaVersion.VERSION_1_8
         targetCompatibility JavaVersion.VERSION_1_8
     }
-    namespace 'com.bitmovin.analytics.conviva'
+    buildFeatures {
+        buildConfig true
+    }
+    kotlinOptions {
+        jvmTarget = '1.8'
+    }
+    publishing {
+        singleVariant("release") {
+            withSourcesJar()
+        }
+    }
 }
 
 dependencies {
-    implementation fileTree(include: ['*.jar'], dir: 'libs')
-    implementation 'androidx.appcompat:appcompat:1.2.0'
+    api 'com.conviva.sdk:conviva-core-sdk:4.0.39'
+    implementation bitmovinPlayerDependencies.bitmovinPlayer
+
     testImplementation testingDependencies.junit
+    testImplementation testingDependencies.mockk
+    testImplementation testingDependencies.strikt
     androidTestImplementation testingDependencies.androidx_junit
     androidTestImplementation testingDependencies.androidx_espresso_core
-    implementation 'com.conviva.sdk:conviva-core-sdk:4.0.33'
-    implementation bitmovinPlayerDependencies.bitmovinPlayer
-    implementation 'org.apache.commons:commons-text:1.7'
 }
 
 publishing {
     publications {
-        aar(MavenPublication) {
+        release(MavenPublication) {
             groupId packageName
             version = libraryVersion
             artifactId project.getName()
 
-            // Tell maven to prepare the generated "*.aar" file for publishing
-            artifact("$buildDir/outputs/aar/${project.getName()}-release.aar")
-
+            // Exclude kotlin-stdlib from the pom file as it is only needed for testing
             pom.withXml {
-                def dependenciesNode = asNode().appendNode('dependencies')
-
-                //Defining configuration names from which dependencies will be taken (debugCompile or releaseCompile and compile)
-                def configurationNames = ['api']
-
-                configurationNames.each { configurationName ->
-                    configurations[configurationName].allDependencies.each {
-                        def dependencyNode = dependenciesNode.appendNode('dependency')
-                        dependencyNode.appendNode('groupId', it.group)
-                        dependencyNode.appendNode('artifactId', it.name)
-                        dependencyNode.appendNode('version', it.version)
-                    }
+                Node pomNode = asNode()
+                pomNode.dependencies.'*'.findAll() {
+                    it.artifactId.text() == 'kotlin-stdlib'
+                }.each() {
+                    it.parent().remove(it)
                 }
             }
+
+            afterEvaluate {
+                from components.release
+            }
         }
     }
 }
@@ -81,7 +88,7 @@ artifactory {
         }
         defaults {
             // Tell the Artifactory Plugin which artifacts should be published to Artifactory.
-            publications('aar')
+            publications('release')
             publishArtifacts = true
 
             // Properties to be attached to the published artifacts.
diff --git a/conviva/src/main/java/com/bitmovin/analytics/conviva/BitmovinPlayerHelper.java b/conviva/src/main/java/com/bitmovin/analytics/conviva/BitmovinPlayerHelper.java
deleted file mode 100644
index 9dd8c4e..0000000
--- a/conviva/src/main/java/com/bitmovin/analytics/conviva/BitmovinPlayerHelper.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package com.bitmovin.analytics.conviva;
-
-import com.bitmovin.player.api.Player;
-
-class BitmovinPlayerHelper {
-    private Player player;
-
-    BitmovinPlayerHelper(Player player) {
-        this.player = player;
-    }
-
-    String getSdkVersionString() {
-        return Player.getSdkVersion();
-    }
-
-    String getStreamType() {
-        if (player.getSource() == null || player.getSource().getConfig() == null) {
-            return null;
-        } else {
-            return player.getSource().getConfig().getType().name();
-        }
-    }
-
-    String getStreamUrl() {
-        if (player.getSource() == null || player.getSource().getConfig() == null) {
-            return null;
-        } else {
-            return player.getSource().getConfig().getUrl();
-        }
-    }
-}
diff --git a/conviva/src/main/java/com/bitmovin/analytics/conviva/ContentMetadataBuilder.java b/conviva/src/main/java/com/bitmovin/analytics/conviva/ContentMetadataBuilder.java
index ec9d021..1ce5f3d 100644
--- a/conviva/src/main/java/com/bitmovin/analytics/conviva/ContentMetadataBuilder.java
+++ b/conviva/src/main/java/com/bitmovin/analytics/conviva/ContentMetadataBuilder.java
@@ -2,11 +2,8 @@
 
 import android.util.Log;
 
-import com.conviva.api.ContentMetadata;
 import com.conviva.sdk.ConvivaSdkConstants;
 
-import org.apache.commons.lang3.ObjectUtils;
-
 import java.util.HashMap;
 import java.util.Map;
 
@@ -22,15 +19,13 @@ class ContentMetadataBuilder {
     private boolean playbackStarted;
 
     ContentMetadataBuilder() {
-        contentInfo = new HashMap<String, Object>();
+        contentInfo = new HashMap<>();
         metadata = new MetadataOverrides();
         metadataOverrides = new MetadataOverrides();
     }
 
     /**
      * This method is used for custom content metadata updates during / before a session.
-     *
-     * @param metadataOverrides
      */
     public void setOverrides(MetadataOverrides metadataOverrides) {
         if (playbackStarted) {
@@ -47,7 +42,7 @@ public void setPlaybackStarted(boolean value) {
     public Map<String, Object> build() {
 
         if (!playbackStarted) {
-            if(!contentInfo.containsKey(ConvivaSdkConstants.ASSET_NAME)) {
+            if (!contentInfo.containsKey(ConvivaSdkConstants.ASSET_NAME)) {
                 contentInfo.put(ConvivaSdkConstants.ASSET_NAME, getAssetName());
             }
 
@@ -60,34 +55,35 @@ public Map<String, Object> build() {
             contentInfo.put(ConvivaSdkConstants.IS_LIVE, isLive);
 
             String applicationName = ObjectUtils.defaultIfNull(
-                metadataOverrides.getApplicationName(),
-                metadata.getApplicationName());
+                    metadataOverrides.getApplicationName(),
+                    metadata.getApplicationName());
             contentInfo.put(ConvivaSdkConstants.PLAYER_NAME, applicationName);
 
             Integer duration = ObjectUtils.defaultIfNull(
-                metadataOverrides.getDuration(),
-                metadata.getDuration());
-            Integer convivaDuration = duration != null ? duration : -1;
-            if(convivaDuration > 0) {
+                    metadataOverrides.getDuration(),
+                    metadata.getDuration());
+            int convivaDuration = duration != null ? duration : -1;
+            if (convivaDuration > 0) {
                 contentInfo.put(ConvivaSdkConstants.DURATION, convivaDuration);
             }
 
             contentInfo.putAll(getCustom());
+            contentInfo.putAll(getAdditionalStandardTags());
         }
 
         Integer frameRate = ObjectUtils.defaultIfNull(
                 metadataOverrides.getEncodedFrameRate(),
                 metadata.getEncodedFrameRate());
         contentInfo.put(ConvivaSdkConstants.ENCODED_FRAMERATE, frameRate != null ? frameRate : -1);
-    
+
         String defaultResource = ObjectUtils.defaultIfNull(
-                 metadataOverrides.getDefaultResource(),
-                 metadata.getDefaultResource());
+                metadataOverrides.getDefaultResource(),
+                metadata.getDefaultResource());
         contentInfo.put(ConvivaSdkConstants.DEFAULT_RESOURCE, defaultResource);
 
         String streamUrl = ObjectUtils.defaultIfNull(
-            metadataOverrides.getStreamUrl(),
-            metadata.getStreamUrl());
+                metadataOverrides.getStreamUrl(),
+                metadata.getStreamUrl());
         contentInfo.put(ConvivaSdkConstants.STREAM_URL, streamUrl);
 
         return contentInfo;
@@ -125,7 +121,7 @@ public Map<String, String> getCustom() {
         // merge internal and override metadata key-value pairs
         // with override values having higher precedence
         Map<String, String> customInternals = metadata.getCustom();
-        Map<String, String> customs = customInternals != null ? customInternals : new HashMap<String, String>();
+        Map<String, String> customs = customInternals != null ? customInternals : new HashMap<>();
         Map<String, String> customOverrides = metadataOverrides.getCustom();
         if (customOverrides != null) {
             customs.putAll(customOverrides);
@@ -133,6 +129,22 @@ public Map<String, String> getCustom() {
         return customs;
     }
 
+    public void setAdditionalStandardTags(Map<String, Object> newValue) {
+        metadata.setAdditionalStandardTags(newValue);
+    }
+
+    public Map<String, Object> getAdditionalStandardTags() {
+        // merge internal and override metadata key-value pairs
+        // with override values having higher precedence
+        Map<String, Object> internalStandardTags = metadata.getAdditionalStandardTags();
+        Map<String, Object> additionalStandardTags = internalStandardTags != null ? internalStandardTags : new HashMap<>();
+        Map<String, Object> additionalStandardTagsOverrides = metadataOverrides.getAdditionalStandardTags();
+        if (additionalStandardTagsOverrides != null) {
+            additionalStandardTags.putAll(additionalStandardTagsOverrides);
+        }
+        return additionalStandardTags;
+    }
+
     public void setDuration(Integer newValue) {
         metadata.setDuration(newValue);
     }
@@ -153,6 +165,6 @@ public void reset() {
         metadataOverrides = new MetadataOverrides();
         metadata = new MetadataOverrides();
         playbackStarted = false;
-        contentInfo = new HashMap<String, Object>();
+        contentInfo = new HashMap<>();
     }
 }
diff --git a/conviva/src/main/java/com/bitmovin/analytics/conviva/ConvivaAnalyticsIntegration.java b/conviva/src/main/java/com/bitmovin/analytics/conviva/ConvivaAnalyticsIntegration.java
index ea75e31..a40fcfc 100644
--- a/conviva/src/main/java/com/bitmovin/analytics/conviva/ConvivaAnalyticsIntegration.java
+++ b/conviva/src/main/java/com/bitmovin/analytics/conviva/ConvivaAnalyticsIntegration.java
@@ -4,90 +4,171 @@
 import android.os.Handler;
 import android.util.Log;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+
+import com.bitmovin.analytics.conviva.ssai.DefaultSsaiApi;
+import com.bitmovin.analytics.conviva.ssai.SsaiApi;
 import com.bitmovin.player.api.Player;
+import com.bitmovin.player.api.advertising.Ad;
+import com.bitmovin.player.api.advertising.AdBreak;
+import com.bitmovin.player.api.advertising.AdData;
+import com.bitmovin.player.api.advertising.AdSourceType;
+import com.bitmovin.player.api.advertising.vast.AdSystem;
+import com.bitmovin.player.api.advertising.vast.VastAdData;
 import com.bitmovin.player.api.deficiency.ErrorEvent;
 import com.bitmovin.player.api.event.Event;
 import com.bitmovin.player.api.event.EventListener;
 import com.bitmovin.player.api.event.PlayerEvent;
 import com.bitmovin.player.api.event.SourceEvent;
-import com.bitmovin.player.api.media.video.quality.VideoQuality;
-import com.bitmovin.player.api.source.Source;
-import com.bitmovin.player.api.source.SourceConfig;
+import com.conviva.sdk.ConvivaAdAnalytics;
 import com.conviva.sdk.ConvivaAnalytics;
+import com.conviva.sdk.ConvivaExperienceAnalytics;
 import com.conviva.sdk.ConvivaSdkConstants;
 import com.conviva.sdk.ConvivaVideoAnalytics;
 
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 public class ConvivaAnalyticsIntegration {
-
+    public static final String STREAM_TYPE = "streamType";
+    public static final String INTEGRATION_VERSION = "integrationVersion";
     private static final String TAG = "ConvivaAnalyticsInt";
 
-    private Player bitmovinPlayer;
-    private ContentMetadataBuilder contentMetadataBuilder = new ContentMetadataBuilder();
-    private ConvivaConfig config;
-    private ConvivaVideoAnalytics convivaVideoAnalytics;
-    private MetadataOverrides metadataOverrides;
+    @NonNull
+    private final ContentMetadataBuilder contentMetadataBuilder = new ContentMetadataBuilder();
+    @NonNull
+    private final ConvivaVideoAnalytics convivaVideoAnalytics;
+    @NonNull
+    private final ConvivaAdAnalytics convivaAdAnalytics;
 
-    // Wrapper to extract bitmovinPlayer helper methods
-    private BitmovinPlayerHelper playerHelper;
+    @Nullable
+    private PlayerDecorator player;
+
+    private MetadataOverrides metadataOverrides;
+    @NonNull
+    private final DefaultSsaiApi ssai;
 
-    // Helper
-    private Boolean adStarted = false;
     private Boolean isSessionActive = false;
+
+    @VisibleForTesting(otherwise = VisibleForTesting.NONE)
+    public Boolean getSessionActive() {
+        return isSessionActive;
+    }
+
     private Boolean isBumper = false;
     private Boolean isBackgrounded = false;
+    @Nullable
+    private AdBreak activeAdBreak;
+
+    public ConvivaAnalyticsIntegration(String customerKey, Context context) {
+        this(
+                null,
+                customerKey,
+                context,
+                new ConvivaConfig(),
+                null,
+                null,
+                null
+        );
+    }
+
+    public ConvivaAnalyticsIntegration(String customerKey, Context context, ConvivaConfig config) {
+        this(
+                null,
+                customerKey,
+                context,
+                config,
+                null,
+                null,
+                null
+        );
+    }
 
     public ConvivaAnalyticsIntegration(Player player, String customerKey, Context context) {
         this(player, customerKey, context, new ConvivaConfig());
     }
 
-    public ConvivaAnalyticsIntegration(Player player,
-                                       String customerKey,
-                                       Context context,
-                                       ConvivaConfig config) {
-        this(player, customerKey, context, config, null);
-    }
-
-    public ConvivaAnalyticsIntegration(Player player,
-                                       String customerKey,
-                                       Context context,
-                                       ConvivaConfig config,
-                                       ConvivaVideoAnalytics videoAnalytics
-                                       ) {
-        this.bitmovinPlayer = player;
-        this.playerHelper = new BitmovinPlayerHelper(player);
-        this.config = config;
-        if(config.getGatewayUrl() != null || config.isDebugLoggingEnabled()) {
-            Map<String, Object> settings = new HashMap<String, Object>();
+    public ConvivaAnalyticsIntegration(
+            Player player,
+            String customerKey,
+            Context context,
+            ConvivaConfig config
+    ) {
+        this(player, customerKey, context, config, null, null, null);
+    }
+
+    @VisibleForTesting()
+    public ConvivaAnalyticsIntegration(
+            @Nullable Player player,
+            String customerKey,
+            Context context,
+            ConvivaConfig config,
+            @Nullable ConvivaVideoAnalytics videoAnalytics,
+            @Nullable ConvivaAdAnalytics adAnalytics,
+            @Nullable DefaultSsaiApi ssai
+    ) {
+        Map<String, Object> settings = new HashMap<>();
+        if (config.getGatewayUrl() != null || config.isDebugLoggingEnabled()) {
             if (config.getGatewayUrl() != null) {
                 settings.put(ConvivaSdkConstants.GATEWAY_URL, config.getGatewayUrl());
             }
             if (config.isDebugLoggingEnabled()) {
                 settings.put(ConvivaSdkConstants.LOG_LEVEL, ConvivaSdkConstants.LogLevel.DEBUG);
             }
-            if(videoAnalytics == null) {
-                ConvivaAnalytics.init(context, customerKey, settings);
-            }
-        } else {
-            if(videoAnalytics == null) {
-                ConvivaAnalytics.init(context, customerKey);
-            }
         }
 
-        if(videoAnalytics != null) {
+        if (videoAnalytics == null) {
+            ConvivaAnalytics.init(context, customerKey, settings);
+            convivaVideoAnalytics = ConvivaAnalytics.buildVideoAnalytics(context);
+        } else {
             convivaVideoAnalytics = videoAnalytics;
+        }
+        if (adAnalytics == null) {
+            convivaAdAnalytics = ConvivaAnalytics.buildAdAnalytics(context, convivaVideoAnalytics);
         } else {
-            convivaVideoAnalytics = ConvivaAnalytics.buildVideoAnalytics(context);
+            convivaAdAnalytics = adAnalytics;
         }
 
-        attachBitmovinEventListeners();
+        if (ssai == null) {
+            this.ssai = new DefaultSsaiApi(convivaVideoAnalytics, convivaAdAnalytics);
+        } else {
+            this.ssai = ssai;
+        }
+        if (player != null) {
+            attachPlayer(player);
+        }
+        setUpAdAnalyticsCallback();
+    }
+
+    private void setUpAdAnalyticsCallback() {
+        convivaAdAnalytics.setCallback(new ConvivaExperienceAnalytics.ICallback() {
+            @Override
+            public void update() {
+                if (isAdActive() && player != null) {
+                    convivaAdAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.PLAY_HEAD_TIME, player.getPlayHeadTimeMillis());
+                }
+            }
+
+            @Override
+            public void update(String s) {
+            }
+        });
+    }
+
+    private boolean isAdActive() {
+        return (player != null && player.isAd()) || ssai.isAdBreakActive();
     }
 
     // region public methods
+    public SsaiApi getSsai() {
+        return ssai;
+    }
+
     public void sendCustomApplicationEvent(String name) {
-        sendCustomApplicationEvent(name, new HashMap<String, Object>());
+        sendCustomApplicationEvent(name, new HashMap<>());
     }
 
     public void sendCustomApplicationEvent(String name, Map<String, Object> attributes) {
@@ -96,7 +177,7 @@ public void sendCustomApplicationEvent(String name, Map<String, Object> attribut
     }
 
     public void sendCustomPlaybackEvent(String name) {
-        sendCustomPlaybackEvent(name, new HashMap<String, Object>());
+        sendCustomPlaybackEvent(name, new HashMap<>());
     }
 
     public void sendCustomPlaybackEvent(String name, Map<String, Object> attributes) {
@@ -111,16 +192,15 @@ public void sendCustomPlaybackEvent(String name, Map<String, Object> attributes)
      * no longer ensure that the session is managed at the correct time. Additional: Since some metadata attributes
      * relies on the players source we can't ensure that all metadata attributes are present at session creation.
      * Therefore it could be that there will be a 'ContentMetadata created late' issue after conviva validation.
-     * <p>
-     * If no source was loaded this method will throw an error.
+     * <p/>
+     * If no no player with loaded source is available, `assetName` must be set via `updateContentMetadata` before
+     * calling this method.
      */
     public void initializeSession() throws ConvivaAnalyticsException {
-        if ((bitmovinPlayer.getSource() == null ||
-                bitmovinPlayer.getSource().getConfig() == null
-                || bitmovinPlayer.getSource().getConfig().getTitle() == null)
+        if ((player == null || player.getStreamTitle() == null)
                 && this.contentMetadataBuilder.getAssetName() == null) {
             throw new ConvivaAnalyticsException(
-                    "AssetName is missing. Load player source (with Title) first or set assetName via updateContentMetadata"
+                    "AssetName is missing. Load player source (with Title) and attach player first or set assetName via updateContentMetadata"
             );
         }
         internalInitializeSession();
@@ -160,18 +240,23 @@ public void release() {
     }
 
     public void release(Boolean releaseConvivaSdk) {
+        convivaAdAnalytics.release();
         convivaVideoAnalytics.release();
-        detachBitmovinEventListeners();
+        if (player != null) {
+            detachBitmovinEventListeners(player);
+        }
         if (releaseConvivaSdk) {
             ConvivaAnalytics.release();
         }
+
+        isSessionActive = false;
     }
 
     /**
      * Sends a custom deficiency event during playback to Conviva's Player Insight. If no session is active it will NOT
      * create one.
      *
-     * @param message Message which will be send to conviva
+     * @param message  Message which will be send to conviva
      * @param severity One of FATAL or WARNING
      */
     public void reportPlaybackDeficiency(String message, ConvivaSdkConstants.ErrorSeverity severity) {
@@ -182,8 +267,8 @@ public void reportPlaybackDeficiency(String message, ConvivaSdkConstants.ErrorSe
      * Sends a custom deficiency event during playback to Conviva's Player Insight. If no session is active it will NOT
      * create one.
      *
-     * @param message Message which will be send to conviva
-     * @param severity One of FATAL or WARNING
+     * @param message    Message which will be send to conviva
+     * @param severity   One of FATAL or WARNING
      * @param endSession Boolean flag if session should be closed after reporting the deficiency
      */
     public void reportPlaybackDeficiency(String message, ConvivaSdkConstants.ErrorSeverity severity, Boolean endSession) {
@@ -219,25 +304,60 @@ public void resumeTracking() {
     }
 
     /**
-     * This should be called when the app is resumed
+     * This should be called when the app is resumed.
+     *
+     * @deprecated There is no need to call this function. This is handled in the conviva-core sdk internally.
      */
+    @Deprecated
     public void reportAppForegrounded() {
         Log.d(TAG, "appForegrounded");
-        ConvivaAnalytics.reportAppForegrounded();
-        isBackgrounded = false;
+        if (isBackgrounded) {
+            ConvivaAnalytics.reportAppForegrounded();
+            isBackgrounded = false;
+        }
     }
 
     /**
      * This should be called when the app is paused
+     *
+     * @deprecated There is no need to call this function. This is handled in the conviva-core sdk internally.
      */
+    @Deprecated
     public void reportAppBackgrounded() {
         Log.d(TAG, "appBackgrounded");
-        if(!isBackgrounded) {
+        if (!isBackgrounded) {
             ConvivaAnalytics.reportAppBackgrounded();
             isBackgrounded = true;
         }
     }
 
+    /**
+     * Attaches a `Player` instance to the Conviva Analytics object.
+     * This method should be called as soon as the `Player` instance is initialized to not miss any tracking.
+     * <p>
+     * Has no effect if there is already a `Player` instance set. Use the `ConvivaAnalyticsIntegration` constructor
+     * without `player` if you plan to attach a `Player` instance later in the life-cycle.
+     */
+    public void attachPlayer(@NonNull Player player) {
+        if (this.player != null) {
+            Log.w(TAG, "There is already a Player instance attached! Ignoring new Player instance.");
+            return;
+        }
+
+        if (player.getSource() != null) {
+            Log.w(
+                    TAG,
+                    "Player already has a source loaded. Please provide the player instance before loading a source."
+            );
+        }
+
+        this.player = new DefaultPlayerDecorator(player);
+        updateSession();
+
+        attachBitmovinEventListeners(this.player);
+        ssai.setPlayer(this.player);
+    }
+
     // endregion
 
     private void ensureConvivaSessionIsCreatedAndInitialized() {
@@ -266,18 +386,19 @@ private void customEvent(Event event, Map<String, Object> attributes) {
     // region Session handling
     private void setupPlayerStateManager() {
         convivaVideoAnalytics.reportPlaybackMetric(ConvivaSdkConstants.PLAYBACK.PLAYER_STATE, ConvivaSdkConstants.PlayerState.STOPPED);
-        Map<String, Object> playerInfo = new HashMap<String, Object>();
-        playerInfo.put(ConvivaSdkConstants.FRAMEWORK_NAME,"Bitmovin Player Android");
-        playerInfo.put(ConvivaSdkConstants.FRAMEWORK_VERSION, playerHelper.getSdkVersionString());
+        Map<String, Object> playerInfo = new HashMap<>();
+        playerInfo.put(ConvivaSdkConstants.FRAMEWORK_NAME, "Bitmovin Player Android");
+        playerInfo.put(ConvivaSdkConstants.FRAMEWORK_VERSION, Player.getSdkVersion());
         convivaVideoAnalytics.setPlayerInfo(playerInfo);
+        convivaAdAnalytics.setAdPlayerInfo(playerInfo);
     }
 
     private void internalInitializeSession() {
-        if(isSessionActive) {
-            return;
-        }
+        if (isSessionActive) return;
+
         Log.d(TAG, "internalInitializeSession");
         createContentMetadata();
+
         convivaVideoAnalytics.reportPlaybackRequested(contentMetadataBuilder.build());
         setupPlayerStateManager();
         if (metadataOverrides != null) {
@@ -287,60 +408,66 @@ private void internalInitializeSession() {
     }
 
     private void updateSession() {
-        this.buildDynamicContentMetadata();
-
-        VideoQuality videoQuality = bitmovinPlayer.getPlaybackVideoData();
-        if (videoQuality != null) {
-            int bitrate = videoQuality.getBitrate() / 1000; // in kbps
-                convivaVideoAnalytics.reportPlaybackMetric(ConvivaSdkConstants.PLAYBACK.RESOLUTION, videoQuality.getHeight(), videoQuality.getWidth());
-                convivaVideoAnalytics.reportPlaybackMetric(ConvivaSdkConstants.PLAYBACK.BITRATE, bitrate);
-                convivaVideoAnalytics.reportPlaybackMetric(ConvivaSdkConstants.PLAYBACK.RENDERED_FRAMERATE, Math.round(videoQuality.getFrameRate()));
+        if (player != null) {
+            updatePlaybackVideoData(player);
+            buildDynamicContentMetadata(player);
         }
 
-        if(isSessionActive) {
+        if (isSessionActive) {
             convivaVideoAnalytics.setContentInfo(contentMetadataBuilder.build());
         }
     }
 
-    private void createContentMetadata() {
-        Source source = bitmovinPlayer.getSource();
-        if (source != null) {
-            SourceConfig sourceConfig = source.getConfig();
-            String overriddenAssetName = metadataOverrides != null ? metadataOverrides.getAssetName() : null;
+    private void updatePlaybackVideoData(@NonNull PlayerDecorator player) {
+        HashMap<String, Object[]> playbackVideoData = player.getPlaybackVideoData();
+        for (Map.Entry<String, Object[]> entry : playbackVideoData.entrySet()) {
+            convivaVideoAnalytics.reportPlaybackMetric(entry.getKey(), entry.getValue());
+            if (ssai.isAdBreakActive()) {
+                convivaAdAnalytics.reportAdMetric(entry.getKey(), entry.getValue());
+            }
+        }
+    }
 
-            if (sourceConfig != null) {
-                contentMetadataBuilder.setAssetName(overriddenAssetName != null ? overriddenAssetName : sourceConfig.getTitle());
+    private void createContentMetadata() {
+        String overriddenAssetName = metadataOverrides != null ? metadataOverrides.getAssetName() : null;
+        if (overriddenAssetName != null) {
+            contentMetadataBuilder.setAssetName(overriddenAssetName);
+        } else {
+            if (player != null && player.getStreamTitle() != null) {
+                contentMetadataBuilder.setAssetName(player.getStreamTitle());
             } else {
-                if(overriddenAssetName != null) {
-                    contentMetadataBuilder.setAssetName(overriddenAssetName);
-                }
+                Log.w(TAG, "No asset name provided for content metadata.");
             }
         }
-        this.buildDynamicContentMetadata();
+
+        if (player != null) {
+            buildDynamicContentMetadata(player);
+        }
     }
 
-    private void buildDynamicContentMetadata() {
+    private void buildDynamicContentMetadata(PlayerDecorator player) {
         // Build custom tags here, though this is static metadata but
         // streamType could be missing at time of session initialization
         // as source information could be unavailable at that time
         Map<String, String> customInternTags = new HashMap<>();
-        customInternTags.put("streamType", playerHelper.getStreamType());
-        customInternTags.put("integrationVersion", BuildConfig.VERSION_NAME);
+        customInternTags.put(STREAM_TYPE, player.getStreamType());
+        customInternTags.put(INTEGRATION_VERSION, BuildConfig.VERSION_NAME);
         contentMetadataBuilder.setCustom(customInternTags);
 
-        if (bitmovinPlayer.isLive()) {
+        if (player.isLive()) {
             contentMetadataBuilder.setStreamType(ConvivaSdkConstants.StreamType.LIVE);
         } else {
             contentMetadataBuilder.setStreamType(ConvivaSdkConstants.StreamType.VOD);
-            contentMetadataBuilder.setDuration((int) bitmovinPlayer.getDuration());
+            contentMetadataBuilder.setDuration((int) player.getDuration());
         }
 
-        contentMetadataBuilder.setStreamUrl(playerHelper.getStreamUrl());
+        contentMetadataBuilder.setStreamUrl(player.getStreamUrl());
     }
 
     private void internalEndSession() {
+        ssai.reset();
         contentMetadataBuilder.reset();
-        if(!isSessionActive) {
+        if (!isSessionActive) {
             return;
         }
         convivaVideoAnalytics.reportPlaybackEnded();
@@ -349,139 +476,135 @@ private void internalEndSession() {
     }
     // endregion
 
-    private void attachBitmovinEventListeners() {
-        bitmovinPlayer.on(SourceEvent.Unloaded.class, onSourceUnloadedListener);
-        bitmovinPlayer.on(PlayerEvent.Error.class, onPlayerErrorListener);
-        bitmovinPlayer.on(SourceEvent.Error.class, onSourceErrorListener);
-        bitmovinPlayer.on(PlayerEvent.Warning.class, onPlayerWarningListener);
-        bitmovinPlayer.on(SourceEvent.Warning.class, onSourceWarningListener);
-
-        bitmovinPlayer.on(PlayerEvent.Muted.class, onMutedListener);
-        bitmovinPlayer.on(PlayerEvent.Unmuted.class, onUnmutedListener);
-
-        // Playback state events
-        bitmovinPlayer.on(PlayerEvent.Play.class, onPlayListener);
-        bitmovinPlayer.on(PlayerEvent.Playing.class, onPlayingListener);
-        bitmovinPlayer.on(PlayerEvent.Paused.class, onPausedListener);
-        bitmovinPlayer.on(PlayerEvent.StallEnded.class, onStallEndedListener);
-        bitmovinPlayer.on(PlayerEvent.StallStarted.class, onStallStartedListener);
-        bitmovinPlayer.on(PlayerEvent.PlaybackFinished.class, onPlaybackFinishedListener);
-
-        // Seek events
-        bitmovinPlayer.on(PlayerEvent.Seeked.class, onSeekedListener);
-        bitmovinPlayer.on(PlayerEvent.Seek.class, onSeekListener);
-
-        // Timeshift events
-        bitmovinPlayer.on(PlayerEvent.TimeShift.class, onTimeShiftListener);
-        bitmovinPlayer.on(PlayerEvent.TimeShifted.class, onTimeShiftedListener);
-
-        // Ad events
-        bitmovinPlayer.on(PlayerEvent.AdStarted.class, onAdStartedListener);
-        bitmovinPlayer.on(PlayerEvent.AdFinished.class, onAdFinishedListener);
-        bitmovinPlayer.on(PlayerEvent.AdSkipped.class, onAdSkippedListener);
-        bitmovinPlayer.on(PlayerEvent.AdError.class, onAdErrorListener);
-
-        bitmovinPlayer.on(PlayerEvent.VideoPlaybackQualityChanged.class, onVideoPlaybackQualityChangedListener);
-    }
-
-    private void detachBitmovinEventListeners() {
-        bitmovinPlayer.off(SourceEvent.Unloaded.class, onSourceUnloadedListener);
-        bitmovinPlayer.off(PlayerEvent.Error.class, onPlayerErrorListener);
-        bitmovinPlayer.off(SourceEvent.Error.class, onSourceErrorListener);
-        bitmovinPlayer.off(PlayerEvent.Warning.class, onPlayerWarningListener);
-        bitmovinPlayer.off(SourceEvent.Warning.class, onSourceWarningListener);
-
-        bitmovinPlayer.off(PlayerEvent.Muted.class, onMutedListener);
-        bitmovinPlayer.off(PlayerEvent.Unmuted.class, onUnmutedListener);
-
-        // Playback state events
-        bitmovinPlayer.off(PlayerEvent.Play.class, onPlayListener);
-        bitmovinPlayer.off(PlayerEvent.Playing.class, onPlayingListener);
-        bitmovinPlayer.off(PlayerEvent.Paused.class, onPausedListener);
-        bitmovinPlayer.off(PlayerEvent.StallEnded.class, onStallEndedListener);
-        bitmovinPlayer.off(PlayerEvent.StallStarted.class, onStallStartedListener);
-        bitmovinPlayer.off(PlayerEvent.PlaybackFinished.class, onPlaybackFinishedListener);
-
-        // Seek events
-        bitmovinPlayer.off(PlayerEvent.Seeked.class, onSeekedListener);
-        bitmovinPlayer.off(PlayerEvent.Seek.class, onSeekListener);
-
-        // Timeshift events
-        bitmovinPlayer.off(PlayerEvent.TimeShift.class, onTimeShiftListener);
-        bitmovinPlayer.off(PlayerEvent.TimeShifted.class, onTimeShiftedListener);
-
-        // Ad events
-        bitmovinPlayer.off(PlayerEvent.AdStarted.class, onAdStartedListener);
-        bitmovinPlayer.off(PlayerEvent.AdFinished.class, onAdFinishedListener);
-        bitmovinPlayer.off(PlayerEvent.AdSkipped.class, onAdSkippedListener);
-        bitmovinPlayer.off(PlayerEvent.AdError.class, onAdErrorListener);
-
-        bitmovinPlayer.off(PlayerEvent.VideoPlaybackQualityChanged.class,
-                onVideoPlaybackQualityChangedListener);
+    private void attachBitmovinEventListeners(PlayerDecorator player) {
+        player.withEventEmitter(eventEmitter -> {
+            eventEmitter.on(SourceEvent.Unloaded.class, onSourceUnloadedListener);
+            eventEmitter.on(PlayerEvent.Error.class, onPlayerErrorListener);
+            eventEmitter.on(SourceEvent.Error.class, onSourceErrorListener);
+            eventEmitter.on(PlayerEvent.Warning.class, onPlayerWarningListener);
+            eventEmitter.on(SourceEvent.Warning.class, onSourceWarningListener);
+
+            eventEmitter.on(PlayerEvent.Muted.class, onMutedListener);
+            eventEmitter.on(PlayerEvent.Unmuted.class, onUnmutedListener);
+
+            // Playback state events
+            eventEmitter.on(PlayerEvent.Play.class, onPlayListener);
+            eventEmitter.on(PlayerEvent.Playing.class, onPlayingListener);
+            eventEmitter.on(PlayerEvent.Paused.class, onPausedListener);
+            eventEmitter.on(PlayerEvent.StallEnded.class, onStallEndedListener);
+            eventEmitter.on(PlayerEvent.StallStarted.class, onStallStartedListener);
+            eventEmitter.on(PlayerEvent.PlaybackFinished.class, onPlaybackFinishedListener);
+
+            // Seek events
+            eventEmitter.on(PlayerEvent.Seeked.class, onSeekedListener);
+            eventEmitter.on(PlayerEvent.Seek.class, onSeekListener);
+
+            // Time shift events
+            eventEmitter.on(PlayerEvent.TimeShift.class, onTimeShiftListener);
+            eventEmitter.on(PlayerEvent.TimeShifted.class, onTimeShiftedListener);
+
+            // Ad events
+            eventEmitter.on(PlayerEvent.AdBreakStarted.class, onAdBreakStarted);
+            eventEmitter.on(PlayerEvent.AdBreakFinished.class, onAdBreakFinished);
+            eventEmitter.on(PlayerEvent.AdStarted.class, onAdStartedListener);
+            eventEmitter.on(PlayerEvent.AdFinished.class, onAdFinishedListener);
+            eventEmitter.on(PlayerEvent.AdSkipped.class, onAdSkippedListener);
+            eventEmitter.on(PlayerEvent.AdError.class, onAdErrorListener);
+            eventEmitter.on(PlayerEvent.TimeChanged.class, onTimeChangedListener);
+
+            eventEmitter.on(PlayerEvent.VideoPlaybackQualityChanged.class, onVideoPlaybackQualityChangedListener);
+        });
+    }
+
+    private void detachBitmovinEventListeners(PlayerDecorator player) {
+        player.withEventEmitter(bitmovinPlayer -> {
+            bitmovinPlayer.off(SourceEvent.Unloaded.class, onSourceUnloadedListener);
+            bitmovinPlayer.off(PlayerEvent.Error.class, onPlayerErrorListener);
+            bitmovinPlayer.off(SourceEvent.Error.class, onSourceErrorListener);
+            bitmovinPlayer.off(PlayerEvent.Warning.class, onPlayerWarningListener);
+            bitmovinPlayer.off(SourceEvent.Warning.class, onSourceWarningListener);
+
+            bitmovinPlayer.off(PlayerEvent.Muted.class, onMutedListener);
+            bitmovinPlayer.off(PlayerEvent.Unmuted.class, onUnmutedListener);
+
+            // Playback state events
+            bitmovinPlayer.off(PlayerEvent.Play.class, onPlayListener);
+            bitmovinPlayer.off(PlayerEvent.Playing.class, onPlayingListener);
+            bitmovinPlayer.off(PlayerEvent.Paused.class, onPausedListener);
+            bitmovinPlayer.off(PlayerEvent.StallEnded.class, onStallEndedListener);
+            bitmovinPlayer.off(PlayerEvent.StallStarted.class, onStallStartedListener);
+            bitmovinPlayer.off(PlayerEvent.PlaybackFinished.class, onPlaybackFinishedListener);
+
+            // Seek events
+            bitmovinPlayer.off(PlayerEvent.Seeked.class, onSeekedListener);
+            bitmovinPlayer.off(PlayerEvent.Seek.class, onSeekListener);
+
+            // Timeshift events
+            bitmovinPlayer.off(PlayerEvent.TimeShift.class, onTimeShiftListener);
+            bitmovinPlayer.off(PlayerEvent.TimeShifted.class, onTimeShiftedListener);
+
+            // Ad events
+            bitmovinPlayer.off(PlayerEvent.AdBreakStarted.class, onAdBreakStarted);
+            bitmovinPlayer.off(PlayerEvent.AdBreakFinished.class, onAdBreakFinished);
+            bitmovinPlayer.off(PlayerEvent.AdStarted.class, onAdStartedListener);
+            bitmovinPlayer.off(PlayerEvent.AdFinished.class, onAdFinishedListener);
+            bitmovinPlayer.off(PlayerEvent.AdSkipped.class, onAdSkippedListener);
+            bitmovinPlayer.off(PlayerEvent.AdError.class, onAdErrorListener);
+            bitmovinPlayer.off(PlayerEvent.TimeChanged.class, onTimeChangedListener);
+
+            bitmovinPlayer.off(PlayerEvent.VideoPlaybackQualityChanged.class, onVideoPlaybackQualityChangedListener);
+        });
     }
 
     private synchronized void transitionState(ConvivaSdkConstants.PlayerState state) {
         Log.d(TAG, "Transitioning to :" + state.name());
         convivaVideoAnalytics.reportPlaybackMetric(ConvivaSdkConstants.PLAYBACK.PLAYER_STATE, state);
-    }
-
-    // region Helper
-
-    private void trackAdEnd() {
-        if (!adStarted) {
-            // Do not track adEnd if no ad is was shown (possible if an error occurred)
-            return;
+        if (isAdActive()) {
+            Log.d(TAG, "Transitioning ad state to: " + state.name());
+            convivaAdAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.PLAYER_STATE, state);
         }
-        adStarted = false;
-
-        Log.d(TAG, "Report ad break ended");
-        convivaVideoAnalytics.reportAdBreakEnded();
     }
-    // endregion
 
     // region Listeners
-    private final EventListener<SourceEvent.Unloaded> onSourceUnloadedListener = new EventListener<SourceEvent.Unloaded>() {
-        @Override
-        public void onEvent(SourceEvent.Unloaded event) {
+    private final EventListener<SourceEvent.Unloaded> onSourceUnloadedListener = event -> {
         // The default SDK error handling is that it triggers the onSourceUnloaded before the onError event.
         // To track errors on Conviva we need to delay the onSourceUnloaded to ensure the onError event is
         // called first.
         // TODO: remove this once the event order is fixed on the Android SDK.
-        new Handler().postDelayed(new Runnable() {
-            @Override
-            public void run() {
-                Log.d(TAG, "[Player Event] SourceUnloaded");
-                internalEndSession();
-            }
+        new Handler().postDelayed(() -> {
+            Log.d(TAG, "[Player Event] SourceUnloaded");
+            internalEndSession();
         }, 100);
-        }
     };
 
-    private final EventListener<PlayerEvent.Error> onPlayerErrorListener = new EventListener<PlayerEvent.Error>() {
-        @Override
-        public void onEvent(PlayerEvent.Error event) {
-            Log.d(TAG, "[Player Event] Error");
-            String message = String.format("%s - %s", event.getCode(), event.getMessage());
-            customEvent(event); // In case of Error, report current stack trace if available
-            convivaVideoAnalytics.reportPlaybackError(message, ConvivaSdkConstants.ErrorSeverity.FATAL);
-            internalEndSession();
-        }
+    private final EventListener<PlayerEvent.Error> onPlayerErrorListener = event -> {
+        Log.d(TAG, "[Player Event] Error");
+        customEvent(event); // In case of Error, report current stack trace if available
+        handleError(String.format("%s - %s", event.getCode(), event.getMessage()));
     };
 
-    private final EventListener<SourceEvent.Error> onSourceErrorListener = new EventListener<SourceEvent.Error>() {
-        @Override
-        public void onEvent(SourceEvent.Error event) {
-            Log.d(TAG, "[Source Event] Error");
-            String message = String.format("%s - %s", event.getCode(), event.getMessage());
-            customEvent(event); // In case of Error, report current stack trace if available
-            convivaVideoAnalytics.reportPlaybackError(message, ConvivaSdkConstants.ErrorSeverity.FATAL);
-            internalEndSession();
-        }
+    private final EventListener<SourceEvent.Error> onSourceErrorListener = event -> {
+        Log.d(TAG, "[Source Event] Error");
+        customEvent(event); // In case of Error, report current stack trace if available
+        handleError(String.format("%s - %s", event.getCode(), event.getMessage()));
     };
 
+    private void handleError(String message) {
+        ConvivaSdkConstants.ErrorSeverity severity = ConvivaSdkConstants.ErrorSeverity.FATAL;
+        if (ssai.isAdBreakActive()) {
+            convivaAdAnalytics.reportAdError(message, severity);
+        }
+        convivaVideoAnalytics.reportPlaybackError(message, severity);
+        internalEndSession();
+    }
+
     private final EventListener<PlayerEvent.Warning> onPlayerWarningListener = new EventListener<PlayerEvent.Warning>() {
         @Override
         public void onEvent(PlayerEvent.Warning warningEvent) {
+            if (!isSessionActive) {
+                Log.d(TAG, "[Player Event] Warning outside of active conviva session. Ignoring.");
+                return;
+            }
             Log.d(TAG, "[Player Event] Warning");
             String message = String.format("%s - %s", warningEvent.getCode(), warningEvent.getMessage());
             convivaVideoAnalytics.reportPlaybackError(message, ConvivaSdkConstants.ErrorSeverity.WARNING);
@@ -491,83 +614,62 @@ public void onEvent(PlayerEvent.Warning warningEvent) {
     private final EventListener<SourceEvent.Warning> onSourceWarningListener = new EventListener<SourceEvent.Warning>() {
         @Override
         public void onEvent(SourceEvent.Warning warningEvent) {
+            if (!isSessionActive) {
+                Log.d(TAG, "[Source Event] Warning outside of active conviva session. Ignoring.");
+                return;
+            }
             Log.d(TAG, "[Source Event] Warning");
             String message = String.format("%s - %s", warningEvent.getCode(), warningEvent.getMessage());
             convivaVideoAnalytics.reportPlaybackError(message, ConvivaSdkConstants.ErrorSeverity.WARNING);
         }
     };
 
-    private final EventListener<PlayerEvent.Muted> onMutedListener = new EventListener<PlayerEvent.Muted>() {
-        @Override
-        public void onEvent(PlayerEvent.Muted event) {
-            Log.d(TAG, "[Player Event] Muted");
-            customEvent(event);
-        }
+    private final EventListener<PlayerEvent.Muted> onMutedListener = event -> {
+        Log.d(TAG, "[Player Event] Muted");
+        customEvent(event);
     };
 
-    private final EventListener<PlayerEvent.Unmuted> onUnmutedListener = new EventListener<PlayerEvent.Unmuted>() {
-        @Override
-        public void onEvent(PlayerEvent.Unmuted event) {
-            Log.d(TAG, "[Player Event] Unmuted");
-            customEvent(event);
-        }
+    private final EventListener<PlayerEvent.Unmuted> onUnmutedListener = event -> {
+        Log.d(TAG, "[Player Event] Unmuted");
+        customEvent(event);
     };
 
     // region Playback state events
-    private final EventListener<PlayerEvent.Play> onPlayListener = new EventListener<PlayerEvent.Play>() {
-        @Override
-        public void onEvent(PlayerEvent.Play playEvent) {
-            Log.d(TAG, "[Player Event] Play");
-            ensureConvivaSessionIsCreatedAndInitialized();
-            updateSession();
-        }
+    private final EventListener<PlayerEvent.Play> onPlayListener = playEvent -> {
+        Log.d(TAG, "[Player Event] Play");
+        ensureConvivaSessionIsCreatedAndInitialized();
+        updateSession();
     };
-
-    private final EventListener<PlayerEvent.Playing> onPlayingListener = new EventListener<PlayerEvent.Playing>() {
-        @Override
-        public void onEvent(PlayerEvent.Playing playingEvent) {
-            Log.d(TAG, "[Player Event] Playing");
-            contentMetadataBuilder.setPlaybackStarted(true);
-            transitionState(ConvivaSdkConstants.PlayerState.PLAYING);
-        }
+    private final EventListener<PlayerEvent.Playing> onPlayingListener = playingEvent -> {
+        Log.d(TAG, "[Player Event] Playing");
+        contentMetadataBuilder.setPlaybackStarted(true);
+        transitionState(ConvivaSdkConstants.PlayerState.PLAYING);
     };
 
-    private EventListener<PlayerEvent.Paused> onPausedListener = new EventListener<PlayerEvent.Paused>() {
-        @Override
-        public void onEvent(PlayerEvent.Paused pausedEvent) {
-            // The default SDK handling is that it triggers the onPaused before the
-            // onError event in case of no internet connectivity. (No onPaused should be triggered)
-            // To ensure that no playback state change will be reported we need to delay the
-            // onPaused event.
-            // TODO: remove this once the event order is fixed on the Android SDK.
-            new Handler().postDelayed(new Runnable() {
-                @Override
-                public void run() {
-                    Log.d(TAG, "[Player Event] Paused");
-                    transitionState(ConvivaSdkConstants.PlayerState.PAUSED);
-                }
-            }, 100);
-        }
+    private final EventListener<PlayerEvent.Paused> onPausedListener = pausedEvent -> {
+        // The default SDK handling is that it triggers the onPaused before the
+        // onError event in case of no internet connectivity. (No onPaused should be triggered)
+        // To ensure that no playback state change will be reported we need to delay the
+        // onPaused event.
+        // TODO: remove this once the event order is fixed on the Android SDK.
+        new Handler().postDelayed(() -> {
+            Log.d(TAG, "[Player Event] Paused");
+            transitionState(ConvivaSdkConstants.PlayerState.PAUSED);
+        }, 100);
     };
 
-    private final EventListener<PlayerEvent.PlaybackFinished> onPlaybackFinishedListener = new EventListener<PlayerEvent.PlaybackFinished>() {
-        @Override
-        public void onEvent(PlayerEvent.PlaybackFinished playbackFinishedEvent) {
-            Log.d(TAG, "[Player Event] PlaybackFinished");
-            transitionState(ConvivaSdkConstants.PlayerState.STOPPED);
-            internalEndSession();
-        }
+    private final EventListener<PlayerEvent.PlaybackFinished> onPlaybackFinishedListener = playbackFinishedEvent -> {
+        Log.d(TAG, "[Player Event] PlaybackFinished");
+        transitionState(ConvivaSdkConstants.PlayerState.STOPPED);
+        internalEndSession();
     };
 
-    private EventListener<PlayerEvent.StallStarted> onStallStartedListener = new EventListener<PlayerEvent.StallStarted>() {
-        @Override
-        public void onEvent(PlayerEvent.StallStarted stallStartedEvent) {
-            Log.d(TAG, "[Player Event] StallStarted");
-            transitionState(ConvivaSdkConstants.PlayerState.BUFFERING);
-        }
+    private final EventListener<PlayerEvent.StallStarted> onStallStartedListener = stallStartedEvent -> {
+        Log.d(TAG, "[Player Event] StallStarted");
+        transitionState(ConvivaSdkConstants.PlayerState.BUFFERING);
     };
 
-    private EventListener<PlayerEvent.StallEnded> onStallEndedListener = new EventListener<PlayerEvent.StallEnded>() {
+    private final EventListener<PlayerEvent.StallEnded> onStallEndedListener = new EventListener<PlayerEvent.StallEnded>() {
         @Override
         public void onEvent(PlayerEvent.StallEnded stallEndedEvent) {
             // The default SDK error handling is that it triggers the onStallEnded before the
@@ -575,63 +677,48 @@ public void onEvent(PlayerEvent.StallEnded stallEndedEvent) {
             // To track errors on Conviva we need to delay the onStallEnded to ensure no
             // playback state change will be reported.
             // TODO: remove this once the event order is fixed on the Android SDK.
-            new Handler().postDelayed(new Runnable() {
-                @Override
-                public void run() {
-                    Log.d(TAG, "[Player Event] StallEnded");
-                    ConvivaSdkConstants.PlayerState state = ConvivaSdkConstants.PlayerState.PLAYING;
-                    if (bitmovinPlayer.isPaused()) {
-                        state = ConvivaSdkConstants.PlayerState.PAUSED;
-                    }
-                    transitionState(state);
+            new Handler().postDelayed(() -> {
+                Log.d(TAG, "[Player Event] StallEnded");
+                ConvivaSdkConstants.PlayerState state = ConvivaSdkConstants.PlayerState.PLAYING;
+                if (player.isPaused()) {
+                    state = ConvivaSdkConstants.PlayerState.PAUSED;
                 }
+                transitionState(state);
             }, 100);
         }
     };
     // endregion
 
     // region Seek and Timeshift events
-    private EventListener<PlayerEvent.Seek> onSeekListener = new EventListener<PlayerEvent.Seek>() {
-        @Override
-        public void onEvent(PlayerEvent.Seek seekEvent) {
-            Log.d(TAG, "[Player Event] Seek");
-            setSeekStart((int) seekEvent.getTo().getTime() * 1000);
-            // Conviva expect notification of buffering events on seek (typically there is always buffering)
-            transitionState(ConvivaSdkConstants.PlayerState.BUFFERING);
-        }
+    private final EventListener<PlayerEvent.Seek> onSeekListener = seekEvent -> {
+        Log.d(TAG, "[Player Event] Seek");
+        setSeekStart((int) seekEvent.getTo().getTime() * 1000);
+        // Conviva expect notification of buffering events on seek (typically there is always buffering)
+        transitionState(ConvivaSdkConstants.PlayerState.BUFFERING);
     };
 
-    private EventListener<PlayerEvent.Seeked> onSeekedListener = new EventListener<PlayerEvent.Seeked>() {
-        @Override
-        public void onEvent(PlayerEvent.Seeked seekedEvent) {
-            Log.d(TAG, "[Player Event] Seeked");
-            setSeekEnd();
-        }
+    private final EventListener<PlayerEvent.Seeked> onSeekedListener = seekedEvent -> {
+        Log.d(TAG, "[Player Event] Seeked");
+        setSeekEnd();
     };
 
-    private EventListener<PlayerEvent.TimeShift> onTimeShiftListener = new EventListener<PlayerEvent.TimeShift>() {
-        @Override
-        public void onEvent(PlayerEvent.TimeShift timeShiftEvent) {
-            Log.d(TAG, "[Player Event] TimeShift");
-            // According to conviva it is valid to pass -1 for seeking in live streams
-            setSeekStart(-1);
-            // Conviva expect notification of buffering events on timeshift (typically there is always buffering)
-            transitionState(ConvivaSdkConstants.PlayerState.BUFFERING);
-        }
+    private final EventListener<PlayerEvent.TimeShift> onTimeShiftListener = timeShiftEvent -> {
+        Log.d(TAG, "[Player Event] TimeShift");
+        // According to conviva it is valid to pass -1 for seeking in live streams
+        setSeekStart(-1);
+        // Conviva expect notification of buffering events on timeshift (typically there is always buffering)
+        transitionState(ConvivaSdkConstants.PlayerState.BUFFERING);
     };
 
-    private EventListener<PlayerEvent.TimeShifted> onTimeShiftedListener = new EventListener<PlayerEvent.TimeShifted>() {
-        @Override
-        public void onEvent(PlayerEvent.TimeShifted timeShiftedEvent) {
-            Log.d(TAG, "[Player Event] TimeShifted");
-            setSeekEnd();
-        }
+    private final EventListener<PlayerEvent.TimeShifted> onTimeShiftedListener = timeShiftedEvent -> {
+        Log.d(TAG, "[Player Event] TimeShifted");
+        setSeekEnd();
     };
 
     private void setSeekStart(int seekTarget) {
         Log.d(TAG, "Sending seek start event");
         convivaVideoAnalytics.reportPlaybackMetric(ConvivaSdkConstants.PLAYBACK.SEEK_STARTED, seekTarget);
-    };
+    }
 
     public void setSeekEnd() {
         Log.d(TAG, "Sending seek end event");
@@ -639,7 +726,7 @@ public void setSeekEnd() {
         // Notify of seek buffering complete at this stage.
         Log.d(TAG, "[Player Event] Update state after buffering");
         ConvivaSdkConstants.PlayerState state = ConvivaSdkConstants.PlayerState.PAUSED;
-        if (bitmovinPlayer.isPlaying()) {
+        if (player != null && player.isPlaying()) {
             state = ConvivaSdkConstants.PlayerState.PLAYING;
         }
         transitionState(state);
@@ -647,48 +734,182 @@ public void setSeekEnd() {
     // endregion
 
     // region Ad events
-    private EventListener<PlayerEvent.AdStarted> onAdStartedListener = new EventListener<PlayerEvent.AdStarted>() {
+
+    private final EventListener<PlayerEvent.AdBreakStarted> onAdBreakStarted = new EventListener<PlayerEvent.AdBreakStarted>() {
+        @Override
+        public void onEvent(PlayerEvent.AdBreakStarted adBreakStarted) {
+            Log.d(TAG, "[Player Event] AdBreakStarted");
+            // For pre-roll ads there is no `PlayerEvent.Play` before the `PlayerEvent.AdBreakStarted`
+            // which means we need to make sure the session is correctly initialized.
+            ensureConvivaSessionIsCreatedAndInitialized();
+            activeAdBreak = adBreakStarted.getAdBreak();
+            convivaVideoAnalytics.reportAdBreakStarted(ConvivaSdkConstants.AdPlayer.CONTENT, ConvivaSdkConstants.AdType.CLIENT_SIDE);
+        }
+    };
+
+    private final EventListener<PlayerEvent.AdBreakFinished> onAdBreakFinished = new EventListener<PlayerEvent.AdBreakFinished>() {
+        @Override
+        public void onEvent(PlayerEvent.AdBreakFinished adBreakFinished) {
+            Log.d(TAG, "[Player Event] AdBreakFinished");
+            convivaVideoAnalytics.reportAdBreakEnded();
+            activeAdBreak = null;
+        }
+    };
+
+    private final EventListener<PlayerEvent.AdStarted> onAdStartedListener = new EventListener<PlayerEvent.AdStarted>() {
         @Override
         public void onEvent(PlayerEvent.AdStarted adStartedEvent) {
             Log.d(TAG, "[Player Event] AdStarted");
-            adStarted = true;
-            convivaVideoAnalytics.reportAdBreakStarted(ConvivaSdkConstants.AdPlayer.CONTENT, ConvivaSdkConstants.AdType.CLIENT_SIDE);
+            Map<String, Object> adInfo = adStartedToAdInfo(adStartedEvent);
+            convivaAdAnalytics.reportAdLoaded(adInfo);
+            convivaAdAnalytics.reportAdStarted(adInfo);
+            convivaAdAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.PLAYER_STATE, ConvivaSdkConstants.PlayerState.PLAYING);
+            Ad ad = adStartedEvent.getAd();
+            if (ad != null) {
+                if (ad.getWidth() != 0 && ad.getHeight() != 0) {
+                    convivaAdAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.RESOLUTION, ad.getWidth(), ad.getHeight());
+                }
+                AdData adData = ad.getData();
+                if (adData != null && adData.getBitrate() != null) {
+                    convivaAdAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.BITRATE, adData.getBitrate());
+                }
+            }
         }
     };
 
-    private EventListener<PlayerEvent.AdFinished> onAdFinishedListener = new EventListener<PlayerEvent.AdFinished>() {
+    private Map<String, Object> adStartedToAdInfo(PlayerEvent.AdStarted adStartedEvent) {
+        Map<String, Object> adInfo = new HashMap<>();
+
+        adInfo.put("c3.ad.id", "NA");
+        adInfo.put("c3.ad.system", "NA");
+        adInfo.put("c3.ad.mediaFileApiFramework", "NA");
+        adInfo.put("c3.ad.firstAdSystem", "NA");
+        adInfo.put("c3.ad.firstAdId", "NA");
+        adInfo.put("c3.ad.firstCreativeId", "NA");
+
+        adInfo.put("c3.ad.technology", "Client Side");
+        if (adStartedEvent.getClientType() == AdSourceType.Ima) {
+            String imaSdkVersion;
+            if (metadataOverrides != null && metadataOverrides.getImaSdkVersion() != null) {
+                imaSdkVersion = metadataOverrides.getImaSdkVersion();
+            } else {
+                imaSdkVersion = "NA";
+            }
+            adInfo.put(ConvivaSdkConstants.FRAMEWORK_NAME, "Google IMA SDK");
+            adInfo.put(ConvivaSdkConstants.FRAMEWORK_VERSION, imaSdkVersion);
+        } else {
+            adInfo.put(ConvivaSdkConstants.FRAMEWORK_NAME, "Bitmovin");
+            adInfo.put(ConvivaSdkConstants.FRAMEWORK_VERSION, Player.getSdkVersion());
+        }
+
+        // default value for isSlate is false for Custom Ad Manager integration
+        adInfo.put("c3.ad.isSlate", "false");
+
+        double scheduleTime;
+        if (activeAdBreak != null) {
+            scheduleTime = activeAdBreak.getScheduleTime();
+        } else {
+            Log.w(
+                    TAG,
+                    "No active ad break found. Using ad start time as ad position. " +
+                            "This may result in inaccurate ad position reporting."
+            );
+            scheduleTime = adStartedEvent.getTimeOffset();
+        }
+        adInfo.put("c3.ad.position", getAdPosition(scheduleTime));
+        adInfo.put(ConvivaSdkConstants.DURATION, adStartedEvent.getDuration());
+        adInfo.put(ConvivaSdkConstants.IS_LIVE, convivaVideoAnalytics.getMetadataInfo().get(ConvivaSdkConstants.IS_LIVE));
+
+        Ad ad = adStartedEvent.getAd();
+        if (ad != null) {
+            if (ad.getMediaFileUrl() != null) {
+                adInfo.put(ConvivaSdkConstants.STREAM_URL, ad.getMediaFileUrl());
+            }
+            if (ad.getId() != null) {
+                adInfo.put("c3.ad.id", ad.getId());
+            }
+
+            if (ad.getData() instanceof VastAdData) {
+                setVastAdMetadata((VastAdData) ad.getData(), adInfo);
+            }
+        }
+        return adInfo;
+    }
+
+    private static void setVastAdMetadata(VastAdData vastAdData, Map<String, Object> adInfo) {
+        if (vastAdData.getAdTitle() != null) {
+            adInfo.put(ConvivaSdkConstants.ASSET_NAME, vastAdData.getAdTitle());
+        }
+        if (vastAdData.getCreative() != null && vastAdData.getCreative().getId() != null) {
+            adInfo.put("c3.ad.creativeId", vastAdData.getCreative().getId());
+        }
+        if (vastAdData.getAdDescription() != null) {
+            adInfo.put("c3.ad.description", vastAdData.getAdDescription());
+        }
+        if (vastAdData.getAdSystem() != null) {
+            adInfo.put("c3.ad.system", vastAdData.getAdSystem().getName());
+        }
+        List<AdSystem> wrapperAdSystems = vastAdData.getWrapperAdSystems();
+        if (!wrapperAdSystems.isEmpty()) {
+            adInfo.put("c3.ad.firstAdSystem", wrapperAdSystems.get(wrapperAdSystems.size() - 1).getName());
+        }
+        String[] wrapperAdIds = vastAdData.getWrapperAdIds();
+        if (wrapperAdIds.length != 0) {
+            adInfo.put("c3.ad.firstAdId", wrapperAdIds[wrapperAdIds.length - 1]);
+        }
+        List<String> wrapperCreativeIds = vastAdData.getWrapperCreativeIds();
+        if (!wrapperCreativeIds.isEmpty()) {
+            adInfo.put("c3.ad.firstCreativeId", wrapperCreativeIds.get(wrapperCreativeIds.size() - 1));
+        }
+    }
+
+    private ConvivaSdkConstants.AdPosition getAdPosition(double timeOffset) {
+        ConvivaSdkConstants.AdPosition adPosition = ConvivaSdkConstants.AdPosition.MIDROLL;
+        if (timeOffset == 0.0) {
+            adPosition = ConvivaSdkConstants.AdPosition.PREROLL;
+        } else if (player != null && timeOffset == player.getDuration()) {
+            adPosition = ConvivaSdkConstants.AdPosition.POSTROLL;
+        }
+        return adPosition;
+    }
+
+    private final EventListener<PlayerEvent.AdFinished> onAdFinishedListener = new EventListener<PlayerEvent.AdFinished>() {
         @Override
-        public void onEvent(PlayerEvent.AdFinished adFinishedEvent) {
+        public void onEvent(PlayerEvent.AdFinished adFinished) {
             Log.d(TAG, "[Player Event] AdFinished");
-            trackAdEnd();
+            convivaAdAnalytics.reportAdEnded();
         }
     };
 
-    private EventListener<PlayerEvent.AdSkipped> onAdSkippedListener = new EventListener<PlayerEvent.AdSkipped>() {
+    private final EventListener<PlayerEvent.AdSkipped> onAdSkippedListener = new EventListener<PlayerEvent.AdSkipped>() {
         @Override
-        public void onEvent(PlayerEvent.AdSkipped adSkippedEvent) {
+        public void onEvent(PlayerEvent.AdSkipped adSkipped) {
             Log.d(TAG, "[Player Event] AdSkipped");
-            customEvent(adSkippedEvent);
-            trackAdEnd();
+            convivaAdAnalytics.reportAdSkipped();
         }
     };
 
-    private EventListener<PlayerEvent.AdError> onAdErrorListener = new EventListener<PlayerEvent.AdError>() {
+    private final EventListener<PlayerEvent.AdError> onAdErrorListener = new EventListener<PlayerEvent.AdError>() {
         @Override
-        public void onEvent(PlayerEvent.AdError adErrorEvent) {
+        public void onEvent(PlayerEvent.AdError adError) {
             Log.d(TAG, "[Player Event] AdError");
-            customEvent(adErrorEvent);
-            trackAdEnd();
+            convivaAdAnalytics.reportAdFailed(adError.getMessage());
         }
     };
+
     // endregion
 
-    private EventListener<PlayerEvent.VideoPlaybackQualityChanged> onVideoPlaybackQualityChangedListener = new EventListener<PlayerEvent.VideoPlaybackQualityChanged>() {
+    private final EventListener<PlayerEvent.VideoPlaybackQualityChanged> onVideoPlaybackQualityChangedListener = videoPlaybackQualityChangedEvent -> {
+        Log.d(TAG, "[Player Event] VideoPlaybackQualityChanged");
+        updateSession();
+    };
+
+    private final EventListener<PlayerEvent.TimeChanged> onTimeChangedListener = new EventListener<PlayerEvent.TimeChanged>() {
         @Override
-        public void onEvent(PlayerEvent.VideoPlaybackQualityChanged videoPlaybackQualityChangedEvent) {
-            Log.d(TAG, "[Player Event] VideoPlaybackQualityChanged");
-            updateSession();
+        public void onEvent(PlayerEvent.TimeChanged timeChangedEvent) {
+            if (isSessionActive) {
+                convivaVideoAnalytics.reportPlaybackMetric(ConvivaSdkConstants.PLAYBACK.PLAY_HEAD_TIME, player.getPlayHeadTimeMillis());
+            }
         }
     };
-    // endregion
 }
diff --git a/conviva/src/main/java/com/bitmovin/analytics/conviva/DefaultPlayerDecorator.java b/conviva/src/main/java/com/bitmovin/analytics/conviva/DefaultPlayerDecorator.java
new file mode 100644
index 0000000..d809e38
--- /dev/null
+++ b/conviva/src/main/java/com/bitmovin/analytics/conviva/DefaultPlayerDecorator.java
@@ -0,0 +1,107 @@
+package com.bitmovin.analytics.conviva;
+
+import com.bitmovin.analytics.conviva.helper.WithEventEmitter;
+import com.bitmovin.player.api.Player;
+import com.bitmovin.player.api.media.video.quality.VideoQuality;
+import com.conviva.sdk.ConvivaSdkConstants;
+
+import java.util.HashMap;
+
+public class DefaultPlayerDecorator implements PlayerDecorator {
+    private final Player player;
+
+    public DefaultPlayerDecorator(Player player) {
+        this.player = player;
+    }
+
+    @Override
+    public ConvivaSdkConstants.PlayerState getPlayerState() {
+        ConvivaSdkConstants.PlayerState state;
+        if (player.isPaused()) {
+            state = ConvivaSdkConstants.PlayerState.PAUSED;
+        } else if (player.isStalled()) {
+            state = ConvivaSdkConstants.PlayerState.BUFFERING;
+        } else {
+            state = ConvivaSdkConstants.PlayerState.PLAYING;
+        }
+        return state;
+    }
+
+    @Override
+    public HashMap<String, Object[]> getPlaybackVideoData() {
+        HashMap<String, Object[]> videoData = new HashMap<>();
+        VideoQuality playbackVideoData = player.getPlaybackVideoData();
+        if (playbackVideoData != null) {
+            videoData.put(ConvivaSdkConstants.PLAYBACK.RESOLUTION, new Object[]{playbackVideoData.getWidth(), playbackVideoData.getHeight()});
+            final int peakBitrate = playbackVideoData.getPeakBitrate();
+            if (peakBitrate != VideoQuality.BITRATE_NO_VALUE) {
+                videoData.put(ConvivaSdkConstants.PLAYBACK.BITRATE, new Object[]{peakBitrate / 1000});
+            }
+            final int averageBitrate = playbackVideoData.getAverageBitrate();
+            if (averageBitrate != VideoQuality.BITRATE_NO_VALUE) {
+                videoData.put(ConvivaSdkConstants.PLAYBACK.AVG_BITRATE, new Object[]{averageBitrate / 1000});
+            }
+            videoData.put(ConvivaSdkConstants.PLAYBACK.RENDERED_FRAMERATE, new Object[]{Math.round(playbackVideoData.getFrameRate())});
+        }
+        return videoData;
+    }
+
+    @Override
+    public String getStreamTitle() {
+        return player.getSource() == null ? null : player.getSource().getConfig().getTitle();
+    }
+
+    @Override
+    public String getStreamType() {
+        return player.getSource() == null ? null : player.getSource().getConfig().getType().name();
+    }
+
+    @Override
+    public String getStreamUrl() {
+        return player.getSource() == null ? null : player.getSource().getConfig().getUrl();
+    }
+
+
+    @Override
+    public boolean isAd() {
+        return player.isAd();
+    }
+
+    @Override
+    public boolean isLive() {
+        return player.isLive();
+    }
+
+    @Override
+    public boolean isPaused() {
+        return player.isPaused();
+    }
+
+    @Override
+    public boolean isPlaying() {
+        return player.isPlaying();
+    }
+
+    @Override
+    public double getDuration() {
+        return player.getDuration();
+    }
+
+    @Override
+    public long getPlayHeadTimeMillis() {
+        if (player.isLive()) {
+            double playerTimeShiftMax = player.getMaxTimeShift();
+            double playerTimeShift = player.getTimeShift();
+            long playerDurationMs = -(Math.round(playerTimeShiftMax * 1000));
+            return playerDurationMs - -(Math.round(playerTimeShift * 1000));
+        } else {
+            double currentTime = player.getCurrentTime();
+            return (long) (currentTime * 1000);
+        }
+    }
+
+    @Override
+    public void withEventEmitter(WithEventEmitter withEventEmitter) {
+        withEventEmitter.call(player);
+    }
+}
diff --git a/conviva/src/main/java/com/bitmovin/analytics/conviva/MetadataOverrides.java b/conviva/src/main/java/com/bitmovin/analytics/conviva/MetadataOverrides.java
index f439fea..c0ab7e6 100644
--- a/conviva/src/main/java/com/bitmovin/analytics/conviva/MetadataOverrides.java
+++ b/conviva/src/main/java/com/bitmovin/analytics/conviva/MetadataOverrides.java
@@ -14,11 +14,13 @@ public class MetadataOverrides {
     private String applicationName;
     private Map<String, String> custom;
     private Integer duration;
+    private Map<String, Object> additionalStandardTags;
 
     // Dynamic
     private Integer encodedFrameRate;
     private String defaultResource;
     private String streamUrl;
+    private String imaSdkVersion;
 
     public String getAssetName() {
         return assetName;
@@ -68,6 +70,18 @@ public void setDuration(Integer duration) {
         this.duration = duration;
     }
 
+    public Map<String, Object> getAdditionalStandardTags() {
+        return additionalStandardTags;
+    }
+
+    /**
+     * Standard Conviva tags that aren't covered by the other fields in this class.
+     * List of tags can be found here: <a href="https://pulse.conviva.com/learning-center/content/sensor_developer_center/sensor_integration/android/android_stream_sensor.htm#PredefinedVideoandContentMetadata">Pre-defined Video and Content Metadata</a>
+     */
+    public void setAdditionalStandardTags(Map<String, Object> additionalStandardTags) {
+        this.additionalStandardTags = additionalStandardTags;
+    }
+
     public Integer getEncodedFrameRate() {
         return encodedFrameRate;
     }
@@ -91,4 +105,16 @@ public String getStreamUrl() {
     public void setStreamUrl(String streamUrl) {
         this.streamUrl = streamUrl;
     }
+
+    public String getImaSdkVersion() {
+        return imaSdkVersion;
+    }
+
+    /**
+     * Set the IMA SDK version to be tracked with client side ads of type
+     * {@link com.bitmovin.player.api.advertising.AdSourceType#Ima}.
+     */
+    public void setImaSdkVersion(String imaSdkVersion) {
+        this.imaSdkVersion = imaSdkVersion;
+    }
 }
diff --git a/conviva/src/main/java/com/bitmovin/analytics/conviva/ObjectUtils.java b/conviva/src/main/java/com/bitmovin/analytics/conviva/ObjectUtils.java
new file mode 100644
index 0000000..4bebd47
--- /dev/null
+++ b/conviva/src/main/java/com/bitmovin/analytics/conviva/ObjectUtils.java
@@ -0,0 +1,7 @@
+package com.bitmovin.analytics.conviva;
+
+/*package*/ class ObjectUtils {
+    public static <T> T defaultIfNull(T object, T defaultValue) {
+        return object != null ? object : defaultValue;
+    }
+}
diff --git a/conviva/src/main/java/com/bitmovin/analytics/conviva/PlayerDecorator.java b/conviva/src/main/java/com/bitmovin/analytics/conviva/PlayerDecorator.java
new file mode 100644
index 0000000..629c8d5
--- /dev/null
+++ b/conviva/src/main/java/com/bitmovin/analytics/conviva/PlayerDecorator.java
@@ -0,0 +1,32 @@
+package com.bitmovin.analytics.conviva;
+
+import com.bitmovin.analytics.conviva.helper.WithEventEmitter;
+import com.conviva.sdk.ConvivaSdkConstants;
+
+import java.util.HashMap;
+
+public interface PlayerDecorator {
+    ConvivaSdkConstants.PlayerState getPlayerState();
+
+    HashMap<String, Object[]> getPlaybackVideoData();
+
+    boolean isAd();
+
+    String getStreamTitle();
+
+    String getStreamType();
+
+    String getStreamUrl();
+
+    long getPlayHeadTimeMillis();
+
+    boolean isLive();
+
+    double getDuration();
+
+    void withEventEmitter(WithEventEmitter withEventEmitter);
+
+    boolean isPaused();
+
+    boolean isPlaying();
+}
diff --git a/conviva/src/main/java/com/bitmovin/analytics/conviva/helper/WithEventEmitter.java b/conviva/src/main/java/com/bitmovin/analytics/conviva/helper/WithEventEmitter.java
new file mode 100644
index 0000000..6a342b3
--- /dev/null
+++ b/conviva/src/main/java/com/bitmovin/analytics/conviva/helper/WithEventEmitter.java
@@ -0,0 +1,8 @@
+package com.bitmovin.analytics.conviva.helper;
+
+import com.bitmovin.player.api.event.Event;
+import com.bitmovin.player.api.event.JavaEventEmitter;
+
+public interface WithEventEmitter {
+    void call(JavaEventEmitter<Event> player);
+}
diff --git a/conviva/src/main/java/com/bitmovin/analytics/conviva/ssai/AdPosition.java b/conviva/src/main/java/com/bitmovin/analytics/conviva/ssai/AdPosition.java
new file mode 100644
index 0000000..29d4756
--- /dev/null
+++ b/conviva/src/main/java/com/bitmovin/analytics/conviva/ssai/AdPosition.java
@@ -0,0 +1,7 @@
+package com.bitmovin.analytics.conviva.ssai;
+
+public enum AdPosition {
+    PREROLL,
+    MIDROLL,
+    POSTROLL;
+}
diff --git a/conviva/src/main/java/com/bitmovin/analytics/conviva/ssai/DefaultSsaiApi.java b/conviva/src/main/java/com/bitmovin/analytics/conviva/ssai/DefaultSsaiApi.java
new file mode 100644
index 0000000..57e8bfd
--- /dev/null
+++ b/conviva/src/main/java/com/bitmovin/analytics/conviva/ssai/DefaultSsaiApi.java
@@ -0,0 +1,208 @@
+package com.bitmovin.analytics.conviva.ssai;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.bitmovin.analytics.conviva.ConvivaAnalyticsIntegration;
+import com.bitmovin.analytics.conviva.PlayerDecorator;
+import com.conviva.sdk.ConvivaAdAnalytics;
+import com.conviva.sdk.ConvivaSdkConstants;
+import com.conviva.sdk.ConvivaVideoAnalytics;
+
+import java.util.HashMap;
+import java.util.Map;
+
+
+public class DefaultSsaiApi implements SsaiApi {
+    private static final String TAG = "DefaultSsaiApi";
+    private final ConvivaVideoAnalytics convivaVideoAnalytics;
+    private final ConvivaAdAnalytics convivaAdAnalytics;
+    @Nullable
+    private PlayerDecorator player;
+
+    public DefaultSsaiApi(
+        ConvivaVideoAnalytics convivaVideoAnalytics,
+        ConvivaAdAnalytics convivaAdAnalytics
+    ) {
+        this.convivaVideoAnalytics = convivaVideoAnalytics;
+        this.convivaAdAnalytics = convivaAdAnalytics;
+    }
+
+    public void setPlayer(@NonNull PlayerDecorator player) {
+        this.player = player;
+    }
+
+    private boolean isAdBreakActive = false;
+
+    @Override
+    public boolean isAdBreakActive() {
+        return isAdBreakActive;
+    }
+
+    @Override
+    public void reportAdBreakStarted() {
+        reportAdBreakStarted(null);
+    }
+
+    public void reset() {
+        reportAdFinished();
+        reportAdBreakFinished();
+    }
+
+    @Override
+    public void reportAdBreakStarted(Map<String, Object> adBreakInfo) {
+        if (isAdBreakActive) {
+            Log.d(TAG, "Server side ad break already active");
+            return;
+        }
+        isAdBreakActive = true;
+        Log.d(TAG, "Server side ad break started");
+        convivaVideoAnalytics.reportAdBreakStarted(ConvivaSdkConstants.AdPlayer.CONTENT, ConvivaSdkConstants.AdType.SERVER_SIDE, adBreakInfo);
+    }
+
+
+    @Override
+    public void reportAdBreakFinished() {
+        if (!isAdBreakActive) {
+            Log.d(TAG, "No server side ad break active");
+            return;
+        }
+        isAdBreakActive = false;
+        Log.d(TAG, "Server side ad break finished");
+        convivaVideoAnalytics.reportAdBreakEnded();
+    }
+
+
+    @Override
+    public void reportAdStarted(AdInfo adInfo) {
+        if (!isAdBreakActive) {
+            Log.d(TAG, "No server side ad break active");
+            return;
+        }
+        if (player == null) {
+            Log.w(TAG, "Player not yet set. Cannot report ad started.");
+            return;
+        }
+        Log.d(TAG, "Server side ad started");
+        convivaAdAnalytics.reportAdStarted(convertToConvivaAdInfo(adInfo, convivaVideoAnalytics.getMetadataInfo()));
+        reportInitialAdMetrics(player);
+    }
+
+    private void reportInitialAdMetrics(@NonNull PlayerDecorator player) {
+        convivaAdAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.PLAYER_STATE, player.getPlayerState());
+        HashMap<String, Object[]> playbackVideoData = player.getPlaybackVideoData();
+        for (Map.Entry<String, Object[]> entry : playbackVideoData.entrySet()) {
+            convivaAdAnalytics.reportAdMetric(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void reportAdFinished() {
+        if (!isAdBreakActive) {
+            Log.d(TAG, "No ad break active");
+            return;
+        }
+        Log.d(TAG, "Server side ad finished");
+        convivaAdAnalytics.reportAdEnded();
+    }
+
+    @Override
+    public void reportAdSkipped() {
+        if (!isAdBreakActive) {
+            Log.d(TAG, "No ad break active");
+            return;
+        }
+        Log.d(TAG, "Server side ad skipped");
+        convivaAdAnalytics.reportAdSkipped();
+    }
+
+    @Override
+    public void updateAdInfo(AdInfo adInfo) {
+        if (!isAdBreakActive) {
+            Log.d(TAG, "No ad break active");
+            return;
+        }
+        Log.d(TAG, "Setting ad info");
+
+        convivaAdAnalytics.setAdInfo(convertToConvivaAdInfo(adInfo, convivaVideoAnalytics.getMetadataInfo()));
+    }
+
+    private static Map<String, Object> convertToConvivaAdInfo(
+            AdInfo adInfo,
+            Map<String, Object> mainContentMetadata
+    ) {
+        HashMap<String, Object> convivaAdInfo = new HashMap<>();
+
+        setDefaults(convivaAdInfo);
+        setFromMainContent(mainContentMetadata, convivaAdInfo);
+        setFromAdInfo(adInfo, convivaAdInfo);
+
+        if (adInfo.getAdditionalMetadata() != null) {
+            convivaAdInfo.putAll(adInfo.getAdditionalMetadata());
+        }
+
+        return convivaAdInfo;
+    }
+
+    private static void setDefaults(HashMap<String, Object> convivaAdInfo) {
+        convivaAdInfo.put("c3.ad.id", "NA");
+        convivaAdInfo.put("c3.ad.system", "NA");
+        convivaAdInfo.put("c3.ad.mediaFileApiFramework", "NA");
+        convivaAdInfo.put("c3.ad.firstAdSystem", "NA");
+        convivaAdInfo.put("c3.ad.firstAdId", "NA");
+        convivaAdInfo.put("c3.ad.firstCreativeId", "NA");
+        convivaAdInfo.put("c3.ad.technology", "Server Side");
+    }
+
+    private static void setFromMainContent(Map<String, Object> mainContentMetadata, HashMap<String, Object> convivaAdInfo) {
+        maybeCopyFromMainContent(mainContentMetadata, convivaAdInfo, ConvivaSdkConstants.STREAM_URL);
+        maybeCopyFromMainContent(mainContentMetadata, convivaAdInfo, ConvivaSdkConstants.ASSET_NAME);
+        maybeCopyFromMainContent(mainContentMetadata, convivaAdInfo, ConvivaSdkConstants.IS_LIVE);
+        maybeCopyFromMainContent(mainContentMetadata, convivaAdInfo, ConvivaSdkConstants.DEFAULT_RESOURCE);
+        maybeCopyFromMainContent(mainContentMetadata, convivaAdInfo, ConvivaSdkConstants.ENCODED_FRAMERATE);
+        maybeCopyFromMainContent(mainContentMetadata, convivaAdInfo, ConvivaAnalyticsIntegration.STREAM_TYPE);
+        maybeCopyFromMainContent(mainContentMetadata, convivaAdInfo, ConvivaAnalyticsIntegration.INTEGRATION_VERSION);
+    }
+
+    private static void maybeCopyFromMainContent(Map<String, Object> mainContentMetadata, HashMap<String, Object> convivaAdInfo, String key) {
+        if (mainContentMetadata.containsKey(key)) {
+            convivaAdInfo.put(key, mainContentMetadata.get(key));
+        }
+    }
+
+    private static void setFromAdInfo(AdInfo adInfo, HashMap<String, Object> convivaAdInfo) {
+        convivaAdInfo.put("c3.ad.isSlate", adInfo.isSlate());
+
+        if (adInfo.getTitle() != null) {
+            convivaAdInfo.put(ConvivaSdkConstants.ASSET_NAME, adInfo.getTitle());
+        }
+        if (adInfo.getDuration() != 0) {
+            convivaAdInfo.put(ConvivaSdkConstants.DURATION, adInfo.getDuration());
+        }
+        if (adInfo.getId() != null) {
+            convivaAdInfo.put("c3.ad.id", adInfo.getId());
+        }
+        if (adInfo.getAdSystem() != null) {
+            convivaAdInfo.put("c3.ad.system", adInfo.getAdSystem());
+        }
+        if (adInfo.getPosition() != null) {
+            convivaAdInfo.put("c3.ad.position", toConvivaAdPosition(adInfo.getPosition()));
+        }
+        if (adInfo.getAdStitcher() != null) {
+            convivaAdInfo.put("c3.ad.stitcher", adInfo.getAdStitcher());
+        }
+    }
+
+    private static ConvivaSdkConstants.AdPosition toConvivaAdPosition(AdPosition position) {
+        switch (position) {
+            case PREROLL:
+                return ConvivaSdkConstants.AdPosition.PREROLL;
+            case POSTROLL:
+                return ConvivaSdkConstants.AdPosition.POSTROLL;
+            default:
+                return ConvivaSdkConstants.AdPosition.MIDROLL;
+        }
+    }
+}
diff --git a/conviva/src/main/java/com/bitmovin/analytics/conviva/ssai/SsaiApi.java b/conviva/src/main/java/com/bitmovin/analytics/conviva/ssai/SsaiApi.java
new file mode 100644
index 0000000..40e9a02
--- /dev/null
+++ b/conviva/src/main/java/com/bitmovin/analytics/conviva/ssai/SsaiApi.java
@@ -0,0 +1,170 @@
+package com.bitmovin.analytics.conviva.ssai;
+
+import java.util.Map;
+
+/**
+ * Enables reporting of server-side ad breaks and ads.
+ */
+public interface SsaiApi {
+    /**
+     * Reports if a server-side ad break is currently active.
+     *
+     * @return <code>true</code> if a server-side ad break is active, <code>false</code> otherwise.
+     */
+    boolean isAdBreakActive();
+
+    /**
+     * Reports the start of a server-side ad break. Must be called before the first ad starts.
+     * Has no effect if a server-side ad break is already playing.
+     */
+    void reportAdBreakStarted();
+
+    /**
+     * Reports the start of a server-side ad break. Must be called before the first ad starts.
+     * Has no effect if a server-side ad break is already playing.
+     *
+     * @param adBreakInfo Map containing metadata about the server-side ad break. Can be <code>null</code>.
+     */
+    void reportAdBreakStarted(Map<String, Object> adBreakInfo);
+
+    /**
+     * Reports the end of a server-side ad break. Must be called after the last ad has finished.
+     * Has no effect if no server-side ad break is currently active.
+     */
+    void reportAdBreakFinished();
+
+    /**
+     * Reports the start of a server-side ad.
+     * <p>
+     * Has to be called after calling the <code>reportAdBreakStarted</code> method.
+     *
+     * @param adInfo Object containing metadata about the server-side ad.
+     */
+    void reportAdStarted(AdInfo adInfo);
+
+    /**
+     * Reports the end of a server-side ad.
+     * Has no effect if no server-side ad is currently playing.
+     */
+    void reportAdFinished();
+
+    /**
+     * Reports that the current ad was skipped.
+     * Has no effect if no server-side ad is playing.
+     */
+    void reportAdSkipped();
+
+    /**
+     * Updates the ad metadata during an active client-side or server-side ad.
+     * Has no effect if no server-side ad is playing.
+     *
+     * @param adInfo Object containing metadata about the ad.
+     */
+    void updateAdInfo(AdInfo adInfo);
+
+    /**
+     * Represents metadata for an ad.
+     */
+    class AdInfo {
+        private String title;
+        private double duration;
+        private String id;
+        private String adSystem;
+        private AdPosition position;
+        private boolean isSlate = false;
+        private String adStitcher;
+        private Map<String, Object> additionalMetadata;
+
+        public double getDuration() {
+            return duration;
+        }
+
+        /**
+         * Duration of the ad, in seconds.
+         */
+        public void setDuration(double duration) {
+            this.duration = duration;
+        }
+
+        public String getId() {
+            return id;
+        }
+
+        /**
+         * The ad ID extracted from the ad server that contains the ad creative.
+         */
+        public void setId(String id) {
+            this.id = id;
+        }
+
+        public String getAdSystem() {
+            return adSystem;
+        }
+
+        /**
+         * The name of the ad system (i.e., the ad server).
+         */
+        public void setAdSystem(String adSystem) {
+            this.adSystem = adSystem;
+        }
+
+        public AdPosition getPosition() {
+            return position;
+        }
+
+        /**
+         * The position of the ad.
+         */
+        public void setPosition(AdPosition position) {
+            this.position = position;
+        }
+
+        public boolean isSlate() {
+            return isSlate;
+        }
+
+        /**
+         * Indicates whether this ad is a slate or not. Set to <code>true</code> for slate and <code>false</code> for a regular ad.
+         * Default is <code>false</code>.
+         */
+        public void setSlate(boolean slate) {
+            isSlate = slate;
+        }
+
+        public String getAdStitcher() {
+            return adStitcher;
+        }
+
+        /**
+         * The name of the ad stitcher.
+         */
+        public void setAdStitcher(String adStitcher) {
+            this.adStitcher = adStitcher;
+        }
+
+        public Map<String, Object> getAdditionalMetadata() {
+            return additionalMetadata;
+        }
+
+        /**
+         * Additional ad metadata. This is a map of key-value pairs that can be used to pass additional metadata about the ad.
+         * A list of ad metadata can be found here: <a href="https://pulse.conviva.com/learning-center/content/sensor_developer_center/sensor_integration/android/android_stream_sensor.htm#IntegrateAdManagers">Conviva documentation</a>
+         * <p>
+         * Metadata provided here will supersede any data provided in the ad break info.
+         */
+        public void setAdditionalMetadata(Map<String, Object> additionalMetadata) {
+            this.additionalMetadata = additionalMetadata;
+        }
+
+        public String getTitle() {
+            return title;
+        }
+
+        /**
+         * The title of the ad.
+         */
+        public void setTitle(String title) {
+            this.title = title;
+        }
+    }
+}
diff --git a/conviva/src/test/kotlin/com/bitmovin/analytics/conviva/ConvivaAnalyticsIntegrationTest.kt b/conviva/src/test/kotlin/com/bitmovin/analytics/conviva/ConvivaAnalyticsIntegrationTest.kt
new file mode 100644
index 0000000..48347ff
--- /dev/null
+++ b/conviva/src/test/kotlin/com/bitmovin/analytics/conviva/ConvivaAnalyticsIntegrationTest.kt
@@ -0,0 +1,286 @@
+package com.bitmovin.analytics.conviva
+
+import android.content.Context
+import android.os.Handler
+import com.bitmovin.analytics.conviva.fixtures.MockPlayer
+import com.bitmovin.analytics.conviva.helper.mockLogging
+import com.bitmovin.analytics.conviva.helper.unmockLogging
+import com.bitmovin.analytics.conviva.ssai.DefaultSsaiApi
+import com.bitmovin.player.api.Player
+import com.bitmovin.player.api.advertising.Ad
+import com.bitmovin.player.api.advertising.AdBreak
+import com.bitmovin.player.api.advertising.AdData
+import com.bitmovin.player.api.advertising.AdSourceType
+import com.bitmovin.player.api.deficiency.PlayerErrorCode
+import com.bitmovin.player.api.deficiency.PlayerWarningCode
+import com.bitmovin.player.api.deficiency.SourceWarningCode
+import com.bitmovin.player.api.event.PlayerEvent
+import com.bitmovin.player.api.event.SourceEvent
+import com.bitmovin.player.api.media.Quality
+import com.bitmovin.player.api.media.video.quality.VideoQuality
+import com.conviva.sdk.ConvivaAdAnalytics
+import com.conviva.sdk.ConvivaSdkConstants
+import com.conviva.sdk.ConvivaSdkConstants.AdPosition
+import com.conviva.sdk.ConvivaVideoAnalytics
+import io.mockk.clearMocks
+import io.mockk.every
+import io.mockk.just
+import io.mockk.mockk
+import io.mockk.mockkConstructor
+import io.mockk.runs
+import io.mockk.unmockkConstructor
+import io.mockk.verify
+import org.junit.After
+import org.junit.AfterClass
+import org.junit.Before
+import org.junit.BeforeClass
+import org.junit.Test
+import strikt.api.expectThat
+import strikt.assertions.containsExactlyInAnyOrder
+import strikt.assertions.isEmpty
+
+class ConvivaAnalyticsIntegrationTest {
+    private val mockedPlayer: Player = mockk(relaxed = true)
+    private val player: MockPlayer = MockPlayer(mockedPlayer)
+    private val videoAnalytics: ConvivaVideoAnalytics = mockk(relaxed = true)
+    private val adAnalytics: ConvivaAdAnalytics = mockk(relaxed = true)
+    private val ssaiApi: DefaultSsaiApi = mockk()
+    private val context: Context = mockk()
+
+    private lateinit var convivaAnalyticsIntegration: ConvivaAnalyticsIntegration
+
+    @Before
+    fun beforeTest() {
+        with(ssaiApi) {
+            every { isAdBreakActive } returns false
+            every { reset() } just runs
+            every { setPlayer(any()) } just runs
+        }
+
+        convivaAnalyticsIntegration = ConvivaAnalyticsIntegration(
+                player,
+                "",
+                context,
+                ConvivaConfig(),
+                videoAnalytics,
+                adAnalytics,
+                ssaiApi,
+        )
+    }
+
+    @After
+    fun afterTest() {
+        clearMocks(mockedPlayer, ssaiApi, videoAnalytics, adAnalytics)
+    }
+
+    @Test
+    fun `initializing subscribes to player events`() {
+        expectThat(player.listeners.keys).containsExactlyInAnyOrder(attachedPlayerEvents)
+    }
+
+    @Test
+    fun `releasing unsubscribes from all events`() {
+        convivaAnalyticsIntegration.release()
+
+        expectThat(player.listeners.values.flatten()).isEmpty()
+    }
+
+    @Test
+    fun `updating after releasing does nothing`() {
+        convivaAnalyticsIntegration.release()
+
+        expectThat(convivaAnalyticsIntegration.sessionActive == false)
+
+        convivaAnalyticsIntegration.updateContentMetadata(MetadataOverrides())
+        verify(exactly = 0) { videoAnalytics.setContentInfo(any()) }
+    }
+
+    @Test
+    fun `reports error to ad analytics during an SSAI ad break`() {
+        every { ssaiApi.isAdBreakActive } returns true
+
+        player.listeners[PlayerEvent.Error::class]?.forEach { it(PlayerEvent.Error(PlayerErrorCode.General, "error")) }
+        verify { adAnalytics.reportAdError(any(), ConvivaSdkConstants.ErrorSeverity.FATAL) }
+    }
+
+    @Test
+    fun `reports player state changes to ad analytics during an SSAI ad break`() {
+        every { ssaiApi.isAdBreakActive } returns true
+
+        player.listeners[PlayerEvent.Playing::class]?.forEach { it(PlayerEvent.Playing(0.0)) }
+        verify { adAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.PLAYER_STATE, ConvivaSdkConstants.PlayerState.PLAYING) }
+
+        player.listeners[PlayerEvent.Paused::class]?.forEach { it(PlayerEvent.Paused(0.0)) }
+        verify { adAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.PLAYER_STATE, ConvivaSdkConstants.PlayerState.PAUSED) }
+
+        player.listeners[PlayerEvent.StallStarted::class]?.forEach { it(PlayerEvent.StallStarted()) }
+        verify { adAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.PLAYER_STATE, ConvivaSdkConstants.PlayerState.BUFFERING) }
+
+        player.listeners[PlayerEvent.StallEnded::class]?.forEach { it(PlayerEvent.StallEnded()) }
+        verify { adAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.PLAYER_STATE, ConvivaSdkConstants.PlayerState.PLAYING) }
+    }
+
+    @Test
+    fun `reports video playback quality changes to ad analytics during an SSAI ad break`() {
+        every { ssaiApi.isAdBreakActive } returns true
+        val newVideoQuality = VideoQuality(
+                id = "id",
+                label = "label",
+                bitrate = 2000,
+                averageBitrate = 1000,
+                peakBitrate = 2000,
+                codec = "codec",
+                frameRate = 10.3F,
+                width = 400,
+                height = 300,
+        )
+        every { mockedPlayer.playbackVideoData } returns newVideoQuality
+
+        player.listeners[PlayerEvent.VideoPlaybackQualityChanged::class]?.forEach { onEvent ->
+            onEvent(PlayerEvent.VideoPlaybackQualityChanged(null, newVideoQuality))
+        }
+
+        verify { adAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.BITRATE, 2) }
+        verify { adAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.AVG_BITRATE, 1) }
+        verify { adAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.RESOLUTION, 400, 300) }
+        verify { adAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.RENDERED_FRAMERATE, 10) }
+    }
+
+    @Test
+    fun `does not report bitrate, if not available`() {
+        every { ssaiApi.isAdBreakActive } returns true
+        Quality.Companion.BITRATE_NO_VALUE
+        val newVideoQuality = VideoQuality(
+            id = "id",
+            label = "label",
+            bitrate = Quality.Companion.BITRATE_NO_VALUE,
+            averageBitrate = Quality.Companion.BITRATE_NO_VALUE,
+            peakBitrate = Quality.Companion.BITRATE_NO_VALUE,
+            codec = "codec",
+            frameRate = 10.3F,
+            width = 400,
+            height = 300,
+        )
+        every { mockedPlayer.playbackVideoData } returns newVideoQuality
+
+        player.listeners[PlayerEvent.VideoPlaybackQualityChanged::class]?.forEach { onEvent ->
+            onEvent(PlayerEvent.VideoPlaybackQualityChanged(null, newVideoQuality))
+        }
+
+        verify(exactly = 0) {
+            adAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.BITRATE, any())
+            adAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.AVG_BITRATE, any())
+        }
+        verify { adAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.RESOLUTION, 400, 300) }
+        verify { adAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.RENDERED_FRAMERATE, 10) }
+    }
+
+    @Test
+    fun `does not report a playback error when receiving a player warning event without active conviva session`() {
+        player.listeners[PlayerEvent.Warning::class]?.forEach { onEvent ->
+            onEvent(PlayerEvent.Warning(PlayerWarningCode.General, "warning"))
+        }
+        verify(exactly = 0) { videoAnalytics.reportPlaybackError(any(), any()) }
+    }
+
+    @Test
+    fun `does not report a playback error when receiving a source warning event without active conviva session`() {
+        player.listeners[SourceEvent.Warning::class]?.forEach { onEvent ->
+            onEvent(SourceEvent.Warning(SourceWarningCode.General, "warning"))
+        }
+        verify(exactly = 0) { videoAnalytics.reportPlaybackError(any(), any()) }
+    }
+
+    @Test
+    fun `reports CSAI ad position based on last ad break schedule time`() {
+        player.listeners[PlayerEvent.AdBreakStarted::class]?.forEach {
+            it(createAdBreakStartedEvent(10.0))
+        }
+
+        verify { videoAnalytics.reportAdBreakStarted(any(), any()) }
+        player.listeners[PlayerEvent.AdStarted::class]?.forEach { it(TEST_AD_STARTED_EVENT) }
+        verify {
+            adAnalytics.reportAdStarted(match { it["c3.ad.position"] == AdPosition.MIDROLL })
+        }
+
+        player.listeners[PlayerEvent.AdBreakStarted::class]?.forEach {
+            it(createAdBreakStartedEvent(0.0))
+        }
+
+        verify { videoAnalytics.reportAdBreakStarted(any(), any()) }
+        player.listeners[PlayerEvent.AdStarted::class]?.forEach { it(TEST_AD_STARTED_EVENT) }
+        verify {
+            adAnalytics.reportAdStarted(match { it["c3.ad.position"] == AdPosition.PREROLL })
+        }
+
+    }
+
+    companion object {
+        @JvmStatic
+        @BeforeClass
+        fun beforeClass() {
+            mockLogging()
+
+            mockkConstructor(Handler::class)
+            every { anyConstructed<Handler>().postDelayed(any(), any()) } answers {
+                firstArg<Runnable>().run()
+                true
+            }
+        }
+
+        @JvmStatic
+        @AfterClass
+        fun afterClass() {
+            unmockLogging()
+            unmockkConstructor(Handler::class)
+        }
+    }
+}
+
+private val attachedPlayerEvents = listOf(
+        PlayerEvent.Play::class,
+        PlayerEvent.Paused::class,
+        PlayerEvent.Error::class,
+        PlayerEvent.Warning::class,
+        PlayerEvent.Muted::class,
+        PlayerEvent.Unmuted::class,
+        PlayerEvent.Playing::class,
+        PlayerEvent.StallEnded::class,
+        PlayerEvent.StallStarted::class,
+        PlayerEvent.PlaybackFinished::class,
+        PlayerEvent.Seek::class,
+        PlayerEvent.Seeked::class,
+        PlayerEvent.TimeShift::class,
+        PlayerEvent.TimeShifted::class,
+        PlayerEvent.AdBreakFinished::class,
+        PlayerEvent.AdBreakStarted::class,
+        PlayerEvent.AdStarted::class,
+        PlayerEvent.AdFinished::class,
+        PlayerEvent.AdSkipped::class,
+        PlayerEvent.AdError::class,
+        PlayerEvent.TimeChanged::class,
+        PlayerEvent.VideoPlaybackQualityChanged::class,
+        SourceEvent.Unloaded::class,
+        SourceEvent.Error::class,
+        SourceEvent.Warning::class,
+)
+
+private val TEST_AD_STARTED_EVENT = PlayerEvent.AdStarted(
+        clientType = AdSourceType.Ima,
+        clickThroughUrl = "clickThroughUrl",
+        duration = 10.0,
+        timeOffset = 10.0,
+        position = "0.0",
+        skipOffset = 10.0,
+        ad = mockk(relaxed = true),
+        indexInQueue = 0,
+)
+
+private fun createAdBreakStartedEvent(scheduleTime: Double): PlayerEvent.AdBreakStarted {
+    val adBreakStarted = PlayerEvent.AdBreakStarted(
+        adBreak = mockk {
+            every { this@mockk.scheduleTime } returns scheduleTime
+        }
+    )
+    return adBreakStarted
+}
diff --git a/conviva/src/test/kotlin/com/bitmovin/analytics/conviva/LatePlayerAttachingTest.kt b/conviva/src/test/kotlin/com/bitmovin/analytics/conviva/LatePlayerAttachingTest.kt
new file mode 100644
index 0000000..c6237ff
--- /dev/null
+++ b/conviva/src/test/kotlin/com/bitmovin/analytics/conviva/LatePlayerAttachingTest.kt
@@ -0,0 +1,83 @@
+package com.bitmovin.analytics.conviva
+
+import android.content.Context
+import com.bitmovin.analytics.conviva.fixtures.MockPlayer
+import com.bitmovin.analytics.conviva.helper.mockLogging
+import com.bitmovin.analytics.conviva.helper.unmockLogging
+import com.bitmovin.analytics.conviva.ssai.DefaultSsaiApi
+import com.bitmovin.player.api.Player
+import com.conviva.sdk.ConvivaAdAnalytics
+import com.conviva.sdk.ConvivaVideoAnalytics
+import io.mockk.clearMocks
+import io.mockk.mockk
+import io.mockk.verify
+import org.junit.After
+import org.junit.AfterClass
+import org.junit.Before
+import org.junit.BeforeClass
+import org.junit.Test
+
+class LatePlayerAttachingTest {
+    private val mockedPlayer: Player = mockk(relaxed = true)
+    private val player: MockPlayer = MockPlayer(mockedPlayer)
+    private val videoAnalytics: ConvivaVideoAnalytics = mockk(relaxed = true)
+    private val adAnalytics: ConvivaAdAnalytics = mockk(relaxed = true)
+    private val ssaiApi: DefaultSsaiApi = mockk(relaxed = true)
+    private val context: Context = mockk()
+
+    private lateinit var convivaAnalyticsIntegration: ConvivaAnalyticsIntegration
+
+    @Before
+    fun beforeTest() {
+        convivaAnalyticsIntegration = ConvivaAnalyticsIntegration(
+            null,
+            "",
+            context,
+            ConvivaConfig(),
+            videoAnalytics,
+            adAnalytics,
+            ssaiApi,
+        )
+    }
+
+    @After
+    fun afterTest() {
+        clearMocks(mockedPlayer, ssaiApi, videoAnalytics, adAnalytics)
+    }
+
+    @Test
+    fun `initialize session without player initializes the session with the externally provided asset name`() {
+        val metadataOverride = MetadataOverrides()
+        metadataOverride.assetName = "MyAsset"
+        convivaAnalyticsIntegration.updateContentMetadata(metadataOverride)
+        convivaAnalyticsIntegration.initializeSession()
+
+        verify { videoAnalytics.reportPlaybackRequested(any()) }
+    }
+
+    @Test
+    fun `initialize session without player and attaching the player while the session is already active`() {
+        val metadataOverride = MetadataOverrides()
+        metadataOverride.assetName = "MyAsset"
+        convivaAnalyticsIntegration.updateContentMetadata(metadataOverride)
+        convivaAnalyticsIntegration.initializeSession()
+
+        convivaAnalyticsIntegration.attachPlayer(player)
+
+        verify { videoAnalytics.setContentInfo(any()) }
+    }
+
+    companion object {
+        @JvmStatic
+        @BeforeClass
+        fun beforeClass() {
+            mockLogging()
+        }
+
+        @JvmStatic
+        @AfterClass
+        fun afterClass() {
+            unmockLogging()
+        }
+    }
+}
diff --git a/conviva/src/test/kotlin/com/bitmovin/analytics/conviva/fixtures/MockPlayer.kt b/conviva/src/test/kotlin/com/bitmovin/analytics/conviva/fixtures/MockPlayer.kt
new file mode 100644
index 0000000..d27345a
--- /dev/null
+++ b/conviva/src/test/kotlin/com/bitmovin/analytics/conviva/fixtures/MockPlayer.kt
@@ -0,0 +1,40 @@
+package com.bitmovin.analytics.conviva.fixtures
+
+import com.bitmovin.player.api.Player
+import com.bitmovin.player.api.event.Event
+import com.bitmovin.player.api.event.EventListener
+import kotlin.reflect.KClass
+
+/**
+ * A test implementation of the [Player] interface that allows overriding its behavior and falling
+ * back to a mocked player for not overridden methods for convenience.
+ */
+@Suppress("UNCHECKED_CAST")
+class MockPlayer(private val player: Player) : Player by player {
+
+    val listeners = mutableMapOf<KClass<out Event>, List<(Event) -> Unit>>()
+    override fun <E : Event> on(eventClass: KClass<E>, action: (E) -> Unit) {
+        listeners[eventClass] = listeners[eventClass].orEmpty() + action as (Event) -> Unit
+    }
+
+    override fun <E : Event> on(eventClass: Class<E>, eventListener: EventListener<in E>) {
+        listeners[eventClass.kotlin] = listeners[eventClass.kotlin].orEmpty() + eventListener::onEvent as (Event) -> Unit
+    }
+
+    override fun <E : Event> off(action: (E) -> Unit) {
+        listeners.entries.removeIf { it.value == action as (Event) -> Unit }
+    }
+
+    override fun <E : Event> off(eventClass: KClass<E>, action: (E) -> Unit) {
+        listeners[eventClass] = listeners[eventClass].orEmpty() - action as (Event) -> Unit
+    }
+
+    override fun <E : Event> off(eventListener: EventListener<in E>) {
+        listeners.entries.removeIf { it.value == eventListener::onEvent as (Event) -> Unit }
+    }
+
+    override fun <E : Event> off(eventClass: Class<E>, eventListener: EventListener<in E>) {
+        listeners[eventClass.kotlin] = listeners[eventClass.kotlin].orEmpty() - eventListener::onEvent as (Event) -> Unit
+    }
+
+}
diff --git a/conviva/src/test/kotlin/com/bitmovin/analytics/conviva/helper/MockLogging.kt b/conviva/src/test/kotlin/com/bitmovin/analytics/conviva/helper/MockLogging.kt
new file mode 100644
index 0000000..ef00013
--- /dev/null
+++ b/conviva/src/test/kotlin/com/bitmovin/analytics/conviva/helper/MockLogging.kt
@@ -0,0 +1,19 @@
+package com.bitmovin.analytics.conviva.helper
+
+import android.util.Log
+import io.mockk.every
+import io.mockk.mockkStatic
+import io.mockk.unmockkStatic
+
+fun mockLogging() {
+    mockkStatic(Log::class)
+    every { Log.v(any(), any()) } returns 0
+    every { Log.d(any(), any()) } returns 0
+    every { Log.i(any(), any()) } returns 0
+    every { Log.e(any(), any()) } returns 0
+    every { Log.w(any(), any<String>()) } returns 0
+}
+
+fun unmockLogging() {
+    unmockkStatic(Log::class)
+}
diff --git a/conviva/src/test/kotlin/com/bitmovin/analytics/conviva/ssai/DefaultSsaiApiTest.kt b/conviva/src/test/kotlin/com/bitmovin/analytics/conviva/ssai/DefaultSsaiApiTest.kt
new file mode 100644
index 0000000..a92a3d6
--- /dev/null
+++ b/conviva/src/test/kotlin/com/bitmovin/analytics/conviva/ssai/DefaultSsaiApiTest.kt
@@ -0,0 +1,301 @@
+package com.bitmovin.analytics.conviva.ssai
+
+import com.bitmovin.analytics.conviva.PlayerDecorator
+import com.bitmovin.analytics.conviva.helper.mockLogging
+import com.bitmovin.analytics.conviva.helper.unmockLogging
+import com.conviva.sdk.ConvivaAdAnalytics
+import com.conviva.sdk.ConvivaSdkConstants
+import com.conviva.sdk.ConvivaVideoAnalytics
+import io.mockk.clearMocks
+import io.mockk.every
+import io.mockk.just
+import io.mockk.mockk
+import io.mockk.runs
+import io.mockk.slot
+import io.mockk.verify
+import org.junit.After
+import org.junit.AfterClass
+import org.junit.Before
+import org.junit.BeforeClass
+import org.junit.Test
+import strikt.api.expectThat
+import strikt.assertions.contains
+import strikt.assertions.containsExactlyInAnyOrder
+import strikt.assertions.isEqualTo
+import strikt.assertions.isFalse
+import strikt.assertions.isTrue
+
+
+class DefaultSsaiApiTest {
+    private val videoAnalytics: ConvivaVideoAnalytics = mockk(relaxed = true)
+    private val adAnalytics: ConvivaAdAnalytics = mockk()
+    private val playerDecorator = mockk<PlayerDecorator>()
+    private lateinit var ssaiApi: DefaultSsaiApi
+
+    @Before
+    fun beforeTest() {
+        every { playerDecorator.playerState } returns ConvivaSdkConstants.PlayerState.PLAYING
+        every { playerDecorator.playbackVideoData } returns hashMapOf<String, Array<Any>>(
+                ConvivaSdkConstants.PLAYBACK.BITRATE to arrayOf(1),
+                ConvivaSdkConstants.PLAYBACK.RESOLUTION to arrayOf(800, 1600),
+                ConvivaSdkConstants.PLAYBACK.RENDERED_FRAMERATE to arrayOf(60),
+        )
+        with(adAnalytics) {
+            every { reportAdMetric(ConvivaSdkConstants.PLAYBACK.PLAYER_STATE, any()) } just runs
+            every { reportAdMetric(ConvivaSdkConstants.PLAYBACK.RESOLUTION, any(), any()) } just runs
+            every { reportAdMetric(ConvivaSdkConstants.PLAYBACK.BITRATE, any()) } just runs
+            every { reportAdMetric(ConvivaSdkConstants.PLAYBACK.RENDERED_FRAMERATE, any()) } just runs
+            every { reportAdStarted(any()) } just runs
+            every { reportAdEnded() } just runs
+            every { reportAdSkipped() } just runs
+            every { setAdInfo(any()) } just runs
+        }
+
+        ssaiApi = DefaultSsaiApi(
+            videoAnalytics,
+            adAnalytics,
+        )
+        ssaiApi.setPlayer(playerDecorator)
+    }
+
+    @After
+    fun afterTest() {
+        clearMocks(videoAnalytics, adAnalytics, playerDecorator)
+    }
+
+
+    @Test
+    fun `reports server side ad break start to conviva after ad break started`() {
+        ssaiApi.reportAdBreakStarted()
+        verify {
+            videoAnalytics.reportAdBreakStarted(
+                    ConvivaSdkConstants.AdPlayer.CONTENT,
+                    ConvivaSdkConstants.AdType.SERVER_SIDE,
+                    any(),
+            )
+        }
+    }
+
+    @Test
+    fun `has active ad break after ad break started`() {
+        ssaiApi.reportAdBreakStarted()
+        expectThat(ssaiApi.isAdBreakActive).isTrue()
+    }
+
+    @Test
+    fun `has no active ad break after ad break finished`() {
+        ssaiApi.reportAdBreakStarted()
+        expectThat(ssaiApi.isAdBreakActive).isTrue()
+
+        ssaiApi.reportAdBreakFinished()
+        expectThat(ssaiApi.isAdBreakActive).isFalse()
+    }
+
+    @Test
+    fun `reports ad start with default values to conviva when ad starts`() {
+        ssaiApi.reportAdBreakStarted()
+        ssaiApi.reportAdStarted(SsaiApi.AdInfo())
+
+        val slot = slot<MutableMap<String, Any>>()
+        verify {
+            adAnalytics.reportAdStarted(capture(slot))
+        }
+
+        expectThat(slot.captured.toList())
+                .containsExactlyInAnyOrder(
+                        listOf(
+                                "c3.ad.id" to "NA",
+                                "c3.ad.system" to "NA",
+                                "c3.ad.mediaFileApiFramework" to "NA",
+                                "c3.ad.firstAdSystem" to "NA",
+                                "c3.ad.firstAdId" to "NA",
+                                "c3.ad.firstCreativeId" to "NA",
+                                "c3.ad.technology" to "Server Side",
+                                "c3.ad.isSlate" to false,
+                        )
+                )
+    }
+
+    @Test
+    fun `reports ad playback state playing to conviva when ad starts`() {
+        ssaiApi.reportAdBreakStarted()
+        ssaiApi.reportAdStarted(SsaiApi.AdInfo())
+
+        verify {
+            adAnalytics.reportAdMetric(
+                    ConvivaSdkConstants.PLAYBACK.PLAYER_STATE,
+                    ConvivaSdkConstants.PlayerState.PLAYING,
+            )
+        }
+    }
+
+    @Test
+    fun `reports ad playback state playing to conviva when ad starts while paused`() {
+        every { playerDecorator.playerState } returns ConvivaSdkConstants.PlayerState.PAUSED
+
+        ssaiApi.reportAdBreakStarted()
+        ssaiApi.reportAdStarted(SsaiApi.AdInfo())
+
+        verify {
+            adAnalytics.reportAdMetric(
+                    ConvivaSdkConstants.PLAYBACK.PLAYER_STATE,
+                    ConvivaSdkConstants.PlayerState.PAUSED,
+            )
+        }
+    }
+
+    @Test
+    fun `reports ad playback state buffering to conviva when ad starts while stalling`() {
+        every { playerDecorator.playerState } returns
+                ConvivaSdkConstants.PlayerState.BUFFERING
+
+        ssaiApi.reportAdBreakStarted()
+        ssaiApi.reportAdStarted(SsaiApi.AdInfo())
+
+        verify {
+            adAnalytics.reportAdMetric(
+                    ConvivaSdkConstants.PLAYBACK.PLAYER_STATE,
+                    ConvivaSdkConstants.PlayerState.BUFFERING,
+            )
+        }
+    }
+
+    @Test
+    fun `reports current playback video quality to conviva on ad start`() {
+        ssaiApi.reportAdBreakStarted()
+        ssaiApi.reportAdStarted(SsaiApi.AdInfo())
+
+        verify {
+            adAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.BITRATE, 1)
+            adAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.RESOLUTION, 800, 1600)
+            adAnalytics.reportAdMetric(ConvivaSdkConstants.PLAYBACK.RENDERED_FRAMERATE, 60)
+        }
+    }
+
+    @Test
+    fun `reports ad start with overwritten metadata when ad starts with additional metadata`() {
+        ssaiApi.reportAdBreakStarted()
+        ssaiApi.reportAdStarted(SsaiApi.AdInfo().apply {
+            id = "adIdSetInFields"
+            additionalMetadata = mapOf("c3.ad.id" to "adIdSetInAdditionalMetadata")
+        })
+
+        val slot = slot<MutableMap<String, Any>>()
+        verify {
+            adAnalytics.reportAdStarted(capture(slot))
+        }
+
+        expectThat(slot.captured["c3.ad.id"]).isEqualTo("adIdSetInAdditionalMetadata")
+    }
+
+    @Test
+    fun `reports ad start with main content metadata when ad starts without overwriting it`() {
+        every { videoAnalytics.metadataInfo } returns mapOf(
+                "streamType" to "mainContentStreamType",
+                ConvivaSdkConstants.ASSET_NAME to "mainContentTitle",
+        )
+
+        ssaiApi.reportAdBreakStarted()
+        ssaiApi.reportAdStarted(SsaiApi.AdInfo().apply {
+            title = "overwrittenTitle"
+        })
+
+        val slot = slot<MutableMap<String, Any>>()
+        verify {
+            adAnalytics.reportAdStarted(capture(slot))
+        }
+
+        expectThat(slot) {
+            get { captured[ConvivaSdkConstants.ASSET_NAME] }.isEqualTo("overwrittenTitle")
+            get { captured["streamType"] }.isEqualTo("mainContentStreamType")
+        }
+    }
+
+    @Test
+    fun `reports ad end to conviva when ad finished`() {
+        ssaiApi.reportAdBreakStarted()
+        ssaiApi.reportAdStarted(SsaiApi.AdInfo())
+        ssaiApi.reportAdFinished()
+
+        verify { adAnalytics.reportAdEnded() }
+    }
+
+    @Test
+    fun `reports ad break end to conviva when ad break finished`() {
+        ssaiApi.reportAdBreakStarted()
+        ssaiApi.reportAdBreakFinished()
+
+        verify { videoAnalytics.reportAdBreakEnded() }
+    }
+
+    @Test
+    fun `reports ad skipped to conviva when ad skipped`() {
+        ssaiApi.reportAdBreakStarted()
+        ssaiApi.reportAdStarted(SsaiApi.AdInfo())
+        ssaiApi.reportAdSkipped()
+
+        verify { adAnalytics.reportAdSkipped() }
+        expectThat(ssaiApi.isAdBreakActive).isTrue()
+    }
+
+    @Test
+    fun `reports ad metadata to conviva when updating ad info`() {
+        ssaiApi.reportAdBreakStarted()
+
+        val testAdInfo = SsaiApi.AdInfo().apply {
+            id = "adId"
+            adSystem = "adSystem"
+            title = "title"
+            position = AdPosition.PREROLL
+            adStitcher = "adStitcher"
+            duration = 1000.0
+            isSlate = true
+            additionalMetadata = mapOf("key" to "value")
+        }
+
+        ssaiApi.updateAdInfo(testAdInfo)
+
+        val slot = slot<MutableMap<String, Any>>()
+        verify { adAnalytics.setAdInfo(capture(slot)) }
+
+        expectThat(slot.captured.toList())
+                .contains(
+                        listOf(
+                                "c3.ad.id" to "adId",
+                                "c3.ad.system" to "adSystem",
+                                ConvivaSdkConstants.ASSET_NAME to "title",
+                                "c3.ad.position" to ConvivaSdkConstants.AdPosition.PREROLL,
+                                "c3.ad.stitcher" to "adStitcher",
+                                ConvivaSdkConstants.DURATION to 1000.0,
+                                "c3.ad.isSlate" to true,
+                                "key" to "value",
+                        )
+                )
+    }
+
+    @Test
+    fun `ends potential ads and ad breaks when resetting`() {
+        ssaiApi.reportAdBreakStarted()
+        ssaiApi.reportAdStarted(SsaiApi.AdInfo())
+
+        ssaiApi.reset()
+
+        verify { adAnalytics.reportAdEnded() }
+        verify { videoAnalytics.reportAdBreakEnded() }
+        expectThat(ssaiApi.isAdBreakActive).isFalse()
+    }
+
+    companion object {
+        @JvmStatic
+        @BeforeClass
+        fun beforeClass() {
+            mockLogging()
+        }
+
+        @JvmStatic
+        @AfterClass
+        fun afterClass() {
+            unmockLogging()
+        }
+    }
+}
diff --git a/dependencies.gradle b/dependencies.gradle
index 15051ac..b2371e3 100644
--- a/dependencies.gradle
+++ b/dependencies.gradle
@@ -1,6 +1,6 @@
 ext {
-    bitmovinPlayerVersion = '3.39.0'
-    googleImaSdk = '3.29.0'
+    bitmovinPlayerVersion = '3.81.0'
+    googleImaSdk = '3.31.0'
     googlePlayAdsIdentifier = '18.0.1'
 
     bitmovinPlayerDependencies = [
@@ -12,6 +12,8 @@ ext {
       junit: 'junit:junit:4.12',
       androidx_junit: 'androidx.test.ext:junit:1.1.5',
       androidx_espresso_core: 'androidx.test.espresso:espresso-core:3.5.1',
-      mockk: 'io.mockk:mockk-android:1.12.0'
+      mockk: 'io.mockk:mockk:1.12.0',
+      mockk_android: 'io.mockk:mockk-android:1.12.0',
+      strikt: 'io.strikt:strikt-core:0.31.0',
     ]
-}
\ No newline at end of file
+}
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 83ce604..7f8f151 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 #Tue Oct 12 15:36:49 CEST 2021
 distributionBase=GRADLE_USER_HOME
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.5-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.2-bin.zip
 distributionPath=wrapper/dists
 zipStorePath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME