This implementation provides a seamless integration between AWS MediaTailor's server-side ad insertion (SSAI), Datazoom's event detection, and In The Game's (ITG) interactive overlay capabilities.

To review complete examples, sample apps, and the full list of available configurations, refer to the ITG Documentation V2.7.

Event Detection and Triggering

Overview

The integration uses a two-SDK approach: the Datazoom SDK acts as the event detection layer, and the ITG SDK handles the interactive overlay rendering. The flow works as follows:

Datazoom SDK attaches to the MediaTailor session for tracking and analytics—firing all required tracking beacons independently.
ITG Glue module binds to the same MediaTailor session, managing overlay scheduling internally.
ITG SDK renders the interactive in-content overlay (pause ad, squeezeback, or L-banner) at the precisely correct moment.
Automatic Cleanup occurs when the session ends or the playback screen is dismissed, seamlessly detaching both integrations.

Event Detection Flow

MediaTailor Session created
       ↓
Datazoom Tracking Setup (datazoomAdapter.setupAdSession) 
ITG Binding (session.attachITG / session.addAdObserver)
       ↓
ITG manages overlay scheduling internally
       ↓
Overlay rendered when ad break is detected
       ↓
Overlay dismissed, video restored

Integration Model by Platform

Android

ITG encapsulates ad scheduling entirely. The developer calls session.attachITG(mITGComponent) once. ITG observes the MediaTailor session internally via onNewNonLinearAd and handles all overlay timing.

iOS / tvOS

ITG uses an explicit ad observer pattern. ITGDatazoomPlugin is registered on the session via session.addAdObserver(adObserver: datazoomPlugin). Internally, the plugin observes onNewNonLinearAds and forwards the ad data to the ITG overlay.

Code Implementation Examples

Android Integration

1. Add the ITG repository

In your settings.gradle / settings.gradle.kts, add the ITG Android repository:

// Groovy / Kotlin DSL
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven {
            url = uri("[https://androidrepo.internal.inthegame.io/repository/android/](https://androidrepo.internal.inthegame.io/repository/android/)")
        }
    }
}

2. Add the Datazoom integration dependency

In your app-level build.gradle / build.gradle.kts:

// Groovy / Kotlin DSL
dependencies {
    // … your existing dependencies
 
    // ITG ⇄ Datazoom glue module
    implementation("io.inthegame.sdk:datazoom:2.7.0.1")
}

3. Wire Datazoom and ITG in Your MediaTailor Flow

3.1 Import the glue helper

import io.inthegame.datazoom.ITGDatazoomUtil.attachITG

Note: attachITG is an extension function on the MediaTailor Session object. It binds the session to your already-initialized ITGPlaybackComponent.

3.2 Attach ITG in the MediaTailor session callback In your component that creates the MediaTailor session:

MediaTailor.createSession(config) { session, contentUrl ->
    session?.let {
        // 1) Connect MediaTailor session to Datazoom
        datazoomAdapter?.setupAdSession(session, surfaceView, contentUrl)
 
        // 2) Apply Glue: bind ITG to the MediaTailor session
        //    mITGComponent must be your already-initialized ITGPlaybackComponent
        session.attachITG(mITGComponent!!)
 
        // 3) Start playback using session.playbackUrl
        //    e.g. exoPlayer.setMediaItem(MediaItem.fromUri(session.playbackUrl))
        //         exoPlayer.prepare()
        //         exoPlayer.play()
    }
}

iOS / tvOS Integration

1. Add the Datazoom–ITG Glue Package

In Xcode, navigate to File → Add Package Dependencies… and add the ITG Apple SDK Swift package:

[https://github.com/Inthegamesdk/itg-apple-sdk.git](https://github.com/Inthegamesdk/itg-apple-sdk.git)

In the package selection screen, add ITGDatazoom as a product to your playback target.

2. Wire Datazoom and ITG in Your MediaTailor Flow

2.1 Import the glue module In the playback component that handles your MediaTailor session (e.g., PlayerViewController):

import ITGDatazoomPlugin

Note: attachITG is an extension function on the MediaTailor Session object. It binds the session to your already-initialized ITGPlaybackComponent.

2.2 Attach ITG in the MediaTailor session callback

MediaTailor.shared.createSession(config: config, callback: { [weak self] session, error in
    guard let self = self else { return }
 
    if let session = session {
        self.session = session
 
        // 1) Create the Datazoom–ITG glue plugin,
        //    passing your ITG overlay as the flexi delegate
        self.datazoomPlugin = ITGDatazoomPlugin(flexiDelegate: self.overlayView)
 
        // 2) Register the plugin as an ad observer on the MediaTailor session
        self.session?.addAdObserver(adObserver: self.datazoomPlugin)
 
        // 3) Create the Datazoom context and configure the ad session
        self.dzAdapter = Datazoom.shared.createContext(player: self.player)
        self.dzAdapter?.configureAdSession(
            adSession: session,
            videoUrl: dataZoomDataUrl,
            videoPlayerView: self.videoView
        )
    }
 
    // 4) Start playback using session.playbackUrl
    if let url = session?.playbackUrl {
        self.player.startVideo(URL(string: url)!)
    }
})

2.3 Stop / Cleanup

Remove the ad observer when leaving the playback screen (e.g., in viewWillDisappear):

override func viewWillDisappear(_ animated: Bool) {
    super.viewWillDisappear(animated)
    session?.removeAdObserver(adObserver: datazoomPlugin)
}

Key Implementation Notes

Initialization Order: The ITG overlay view must be initialized and loaded before the MediaTailor session callback fires. The glue module requires the overlay reference at construction time.
Same Player Instance: Both the ITG component and the Datazoom adapter must be bound to the identical player instance (ExoPlayer on Android, AVPlayer on iOS).
Tracking Accuracy: Datazoom fires all MediaTailor tracking beacons. ITG independently fires VAST impression/tracking beacons specifically for the overlay creative. Both systems operate in parallel with no event duplication.
SSAI & SegmentationTypeId 52: When MediaTailor receives a SCTE-35 signal with SegmentationTypeId 52, it does not stitch a replacement clip. Instead, it signals the client to render a client-side overlay. Datazoom detects this signal, and ITG subsequently renders the appropriate ad format (pause ad, squeezeback, or L-banner based on the VAST response).
Cleanup: Always execute cleanup routines (removeAdObserver on iOS or let the ITG component handle session detachment on Android) when tearing down playback to avoid phantom overlay events in future sessions.