diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 65ea9f36..68c760d7 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -27,3 +27,6 @@ jobs:
         uses: gradle/actions/setup-gradle@v3
       - name: Run unit tests
         run: ./gradlew testReleaseUnitTest
+        env:
+          YOSPACE_USERNAME: ${{ secrets.YOSPACE_USERNAME }}
+          YOSPACE_PASSWORD: ${{ secrets.YOSPACE_PASSWORD }}
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 60a23a08..c353be07 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -39,6 +39,9 @@ jobs:
         uses: gradle/actions/setup-gradle@v3
       - name: Build API documentation with Dokka
         run: ./gradlew :dokkaHtmlMultiModule --no-configuration-cache
+        env:
+          YOSPACE_USERNAME: ${{ secrets.YOSPACE_USERNAME }}
+          YOSPACE_PASSWORD: ${{ secrets.YOSPACE_PASSWORD }}
       - name: Upload artifact
         uses: actions/upload-pages-artifact@v3
         with:
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index 5003a6f6..f00db872 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -33,3 +33,5 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           REPOSILITE_USERNAME: ${{ secrets.REPOSILITE_USERNAME }}
           REPOSILITE_PASSWORD: ${{ secrets.REPOSILITE_PASSWORD }}
+          YOSPACE_USERNAME: ${{ secrets.YOSPACE_USERNAME }}
+          YOSPACE_PASSWORD: ${{ secrets.YOSPACE_PASSWORD }}
diff --git a/app/build.gradle b/app/build.gradle
index 1260da3f..db22bf71 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -10,6 +10,7 @@ android {
     defaultConfig {
         applicationId "com.theoplayer.android.connector"
         minSdk 21
+        targetSdk 34
         versionCode 1
         versionName "1.0"
     }
@@ -47,4 +48,6 @@ dependencies {
     implementation "com.nielsenappsdk.global:ad:9.2.0.0"
     implementation project(':connectors:analytics:comscore')
     implementation "com.comscore:android-analytics:$comscoreVersion"
+    implementation project(':connectors:yospace')
+    implementation "com.yospace:admanagement-sdk:$yospaceVersion"
 }
\ No newline at end of file
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 24da06a1..f40ce51f 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -3,6 +3,7 @@
     xmlns:tools="http://schemas.android.com/tools">
 
     <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
 
     <application
         android:allowBackup="true"
diff --git a/app/src/main/java/com/theoplayer/android/connector/MainActivity.kt b/app/src/main/java/com/theoplayer/android/connector/MainActivity.kt
index 97b8a1af..5482ef65 100644
--- a/app/src/main/java/com/theoplayer/android/connector/MainActivity.kt
+++ b/app/src/main/java/com/theoplayer/android/connector/MainActivity.kt
@@ -1,32 +1,39 @@
 package com.theoplayer.android.connector
 
 import android.os.Bundle
+import android.util.Log
 import android.view.View
 import android.view.ViewGroup
 import android.view.ViewGroup.LayoutParams.MATCH_PARENT
 import android.widget.FrameLayout
+import androidx.appcompat.app.AlertDialog
 import androidx.appcompat.app.AppCompatActivity
 import com.theoplayer.android.api.THEOplayerConfig
 import com.theoplayer.android.api.THEOplayerView
+import com.theoplayer.android.api.ads.LinearAd
 import com.theoplayer.android.api.ads.ima.GoogleImaIntegrationFactory
-import com.theoplayer.android.api.source.SourceDescription
-import com.theoplayer.android.api.source.TypedSource
-import com.theoplayer.android.api.source.addescription.GoogleImaAdDescription
-import com.theoplayer.android.api.source.metadata.MetadataDescription
-import com.theoplayer.android.connector.analytics.conviva.ConvivaConfiguration
-import com.theoplayer.android.connector.analytics.conviva.ConvivaConnector
-import com.theoplayer.android.connector.analytics.nielsen.NielsenConnector
+import com.theoplayer.android.api.event.ads.AdBreakEvent
+import com.theoplayer.android.api.event.ads.AdsEventTypes
+import com.theoplayer.android.api.event.ads.SingleAdEvent
 import com.theoplayer.android.connector.analytics.comscore.ComscoreConfiguration
 import com.theoplayer.android.connector.analytics.comscore.ComscoreConnector
 import com.theoplayer.android.connector.analytics.comscore.ComscoreMediaType
 import com.theoplayer.android.connector.analytics.comscore.ComscoreMetaData
+import com.theoplayer.android.connector.analytics.conviva.ConvivaConfiguration
+import com.theoplayer.android.connector.analytics.conviva.ConvivaConnector
+import com.theoplayer.android.connector.analytics.nielsen.NielsenConnector
+import com.theoplayer.android.connector.yospace.YospaceConnector
+
+const val TAG = "MainActivity"
 
 class MainActivity : AppCompatActivity() {
 
     private lateinit var theoplayerView: THEOplayerView
-    private var convivaConnector: ConvivaConnector? = null
-    private var nielsenConnector: NielsenConnector? = null
+    private lateinit var convivaConnector: ConvivaConnector
+    private lateinit var nielsenConnector: NielsenConnector
     private lateinit var comscoreConnector: ComscoreConnector
+    private lateinit var yospaceConnector: YospaceConnector
+    private var selectedSource: Source = sources.first()
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
@@ -37,6 +44,8 @@ class MainActivity : AppCompatActivity() {
         setupConviva()
         setupComscore()
         setupNielsen()
+        setupYospace()
+        setupListeners()
     }
 
     private fun setupComscore() {
@@ -130,21 +139,65 @@ class MainActivity : AppCompatActivity() {
         nielsenConnector = NielsenConnector(applicationContext, theoplayerView.player, appId, true)
     }
 
-    fun setSource(view: View) {
-        theoplayerView.player.source = SourceDescription.Builder(
-            TypedSource.Builder("https://cdn.theoplayer.com/video/big_buck_bunny/big_buck_bunny.m3u8")
-                .build()
+    private fun setupYospace() {
+        yospaceConnector = YospaceConnector(theoplayerView)
+    }
+
+    private fun setupListeners() {
+        val ads = theoplayerView.player.ads
+        ads.addEventListener(AdsEventTypes.ADD_AD, ::onAdEvent)
+        ads.addEventListener(AdsEventTypes.AD_BEGIN, ::onAdEvent)
+        ads.addEventListener(AdsEventTypes.AD_END, ::onAdEvent)
+        ads.addEventListener(AdsEventTypes.AD_SKIP, ::onAdEvent)
+        ads.addEventListener(AdsEventTypes.AD_FIRST_QUARTILE, ::onAdEvent)
+        ads.addEventListener(AdsEventTypes.AD_MIDPOINT, ::onAdEvent)
+        ads.addEventListener(AdsEventTypes.AD_THIRD_QUARTILE, ::onAdEvent)
+        ads.addEventListener(AdsEventTypes.ADD_AD_BREAK, ::onAdBreakEvent)
+        ads.addEventListener(AdsEventTypes.AD_BREAK_BEGIN, ::onAdBreakEvent)
+        ads.addEventListener(AdsEventTypes.AD_BREAK_END, ::onAdBreakEvent)
+        ads.addEventListener(AdsEventTypes.AD_BREAK_CHANGE, ::onAdBreakEvent)
+        ads.addEventListener(AdsEventTypes.REMOVE_AD_BREAK, ::onAdBreakEvent)
+    }
+
+    fun onAdBreakEvent(event: AdBreakEvent<*>) {
+        val adBreak = event.adBreak
+        Log.d(
+            TAG,
+            "${event.type} - " +
+                    "timeOffset=${adBreak.timeOffset}, ads=${adBreak.ads.size}," +
+                    " maxDuration=${adBreak.maxDuration}," +
+                    " currentTime=${theoplayerView.player.currentTime}"
+        )
+    }
+
+    fun onAdEvent(event: SingleAdEvent<*>) {
+        val ad = event.ad ?: return
+        Log.d(
+            TAG,
+            "${event.type} - " +
+                    "id=${ad.id}, type=${ad.type}, adBreak.timeOffset=${ad.adBreak?.timeOffset}," +
+                    (if (ad is LinearAd) " duration=${ad.duration}," else "") +
+                    " currentTime=${theoplayerView.player.currentTime}"
         )
-        .ads(
-            GoogleImaAdDescription.Builder("https://cdn.theoplayer.com/demos/ads/vast/dfp-linear-inline-no-skip.xml")
-                .timeOffset("5")
-                .build()
-        ).metadata(MetadataDescription(mapOf("title" to "BigBuckBunny with Google IMA ads")))
-        .build()
-        nielsenConnector?.updateMetadata(hashMapOf(
-            "assetid" to "C112233",
-            "program" to "BigBuckBunny with Google IMA ads"
-        ))
+    }
+
+    fun selectSource(view: View) {
+        val sourceNames = sources.map { it.name }.toTypedArray()
+        val selectedIndex = sources.indexOf(selectedSource)
+        AlertDialog.Builder(this)
+            .setTitle("Select source")
+            .setSingleChoiceItems(sourceNames, selectedIndex) { dialog, which ->
+                setSource(sources[which])
+                dialog.dismiss()
+            }
+            .create()
+            .show()
+    }
+
+    private fun setSource(source: Source) {
+        selectedSource = source
+        theoplayerView.player.source = source.sourceDescription
+        nielsenConnector.updateMetadata(source.nielsenMetadata)
     }
 
     fun playPause(view: View) {
@@ -177,4 +230,4 @@ class MainActivity : AppCompatActivity() {
         super.onDestroy()
         theoplayerView.onDestroy()
     }
-}
\ No newline at end of file
+}
diff --git a/app/src/main/java/com/theoplayer/android/connector/Sources.kt b/app/src/main/java/com/theoplayer/android/connector/Sources.kt
new file mode 100644
index 00000000..bba4a929
--- /dev/null
+++ b/app/src/main/java/com/theoplayer/android/connector/Sources.kt
@@ -0,0 +1,104 @@
+package com.theoplayer.android.connector
+
+import com.theoplayer.android.api.source.SourceDescription
+import com.theoplayer.android.api.source.SourceType
+import com.theoplayer.android.api.source.TypedSource
+import com.theoplayer.android.api.source.addescription.GoogleImaAdDescription
+import com.theoplayer.android.api.source.metadata.MetadataDescription
+import com.theoplayer.android.connector.yospace.YospaceSsaiDescription
+import com.theoplayer.android.connector.yospace.YospaceStreamType
+
+data class Source(
+    val name: String,
+    val sourceDescription: SourceDescription,
+    val nielsenMetadata: HashMap<String, Any> = hashMapOf()
+)
+
+val sources: List<Source> by lazy {
+    listOf(
+        Source(
+            name = "BigBuckBunny with Google IMA ads",
+            sourceDescription = SourceDescription
+                .Builder(
+                    TypedSource.Builder("https://cdn.theoplayer.com/video/big_buck_bunny/big_buck_bunny.m3u8")
+                        .build()
+                )
+                .ads(
+                    GoogleImaAdDescription.Builder("https://cdn.theoplayer.com/demos/ads/vast/dfp-linear-inline-no-skip.xml")
+                        .timeOffset("5")
+                        .build()
+                )
+                .metadata(MetadataDescription(mapOf("title" to "BigBuckBunny with Google IMA ads")))
+                .build(),
+            nielsenMetadata = hashMapOf(
+                "assetid" to "C112233",
+                "program" to "BigBuckBunny with Google IMA ads"
+            )
+        ),
+        Source(
+            name = "Yospace HLS VOD",
+            sourceDescription = SourceDescription
+                .Builder(
+                    TypedSource.Builder(
+                        "https://csm-e-sdk-validation.bln1.yospace.com/csm/access/156611618/c2FtcGxlL21hc3Rlci5tM3U4?yo.av=4"
+                    )
+                        .type(SourceType.HLS)
+                        .ssai(YospaceSsaiDescription(streamType = YospaceStreamType.VOD))
+                        .build()
+                )
+                .build()
+        ),
+        Source(
+            name = "Yospace HLS Live",
+            sourceDescription = SourceDescription
+                .Builder(
+                    TypedSource.Builder(
+                        "https://csm-e-sdk-validation.bln1.yospace.com/csm/extlive/yospace02,hlssample42.m3u8?yo.br=true&yo.av=4"
+                    )
+                        .type(SourceType.HLS)
+                        .ssai(YospaceSsaiDescription(streamType = YospaceStreamType.LIVE))
+                        .build()
+                )
+                .build()
+        ),
+        Source(
+            name = "Yospace HLS DVRLive",
+            sourceDescription = SourceDescription
+                .Builder(
+                    TypedSource.Builder(
+                        "https://csm-e-sdk-validation.bln1.yospace.com/csm/extlive/yospace02,hlssample42.m3u8?yo.br=true&yo.lp=true&yo.av=4"
+                    )
+                        .type(SourceType.HLS)
+                        .ssai(YospaceSsaiDescription(streamType = YospaceStreamType.LIVEPAUSE))
+                        .build()
+                )
+                .build()
+        ),
+        Source(
+            name = "Yospace DASH Live",
+            sourceDescription = SourceDescription
+                .Builder(
+                    TypedSource.Builder(
+                        "https://csm-e-sdk-validation.bln1.yospace.com/csm/extlive/yosdk01,t2-dash.mpd?yo.br=true&yo.av=4"
+                    )
+                        .type(SourceType.DASH)
+                        .ssai(YospaceSsaiDescription(streamType = YospaceStreamType.LIVE))
+                        .build()
+                )
+                .build()
+        ),
+        Source(
+            name = "Yospace DASH DVRLive",
+            sourceDescription = SourceDescription
+                .Builder(
+                    TypedSource.Builder(
+                        "https://csm-e-sdk-validation.bln1.yospace.com/csm/extlive/yosdk01,dash.mpd?yo.br=true&yo.lp=true&yo.jt=1000&yo.av=4"
+                    )
+                        .type(SourceType.DASH)
+                        .ssai(YospaceSsaiDescription(streamType = YospaceStreamType.LIVEPAUSE))
+                        .build()
+                )
+                .build()
+        )
+    )
+}
\ No newline at end of file
diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml
index 0071c604..8ba4d19a 100644
--- a/app/src/main/res/layout/activity_main.xml
+++ b/app/src/main/res/layout/activity_main.xml
@@ -27,7 +27,7 @@
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:text="set source"
-            android:onClick="setSource"/>
+            android:onClick="selectSource"/>
         <Space
             android:layout_width="0dp"
             android:layout_height="1dp"
diff --git a/build.gradle b/build.gradle
index 4632a94a..38a5bd4a 100644
--- a/build.gradle
+++ b/build.gradle
@@ -19,6 +19,7 @@ plugins {
     id 'com.android.library' version '8.4.1' apply false
     id 'org.jetbrains.kotlin.android' version '1.8.10' apply false
     id 'org.jetbrains.dokka' version '1.9.20'
+    id 'org.jetbrains.kotlin.plugin.serialization' version '1.9.22' apply false
 }
 
 tasks.register('updateVersion') {
diff --git a/connectors/analytics/nielsen/src/main/java/com/theoplayer/android/connector/analytics/nielsen/NielsenHandler.kt b/connectors/analytics/nielsen/src/main/java/com/theoplayer/android/connector/analytics/nielsen/NielsenHandler.kt
index 88d9498c..61edbb5e 100644
--- a/connectors/analytics/nielsen/src/main/java/com/theoplayer/android/connector/analytics/nielsen/NielsenHandler.kt
+++ b/connectors/analytics/nielsen/src/main/java/com/theoplayer/android/connector/analytics/nielsen/NielsenHandler.kt
@@ -63,7 +63,7 @@ class NielsenHandler(
     private val onCueEnterEmsg: EventListener<EnterCueEvent>
 
     private var lastPosition: Long = -1
-    private var appSdk: AppSdk? = null
+    private var appSdk: AppSdk
 
     private var sessionInProgress: Boolean = false
     private val mainHandler = Handler(Looper.getMainLooper())
@@ -83,7 +83,7 @@ class NielsenHandler(
             maybeSendPlayEvent()
         }
         onPause = EventListener<PauseEvent> {
-            appSdk?.stop()
+            appSdk.stop()
         }
         onDurationChange = EventListener<DurationChangeEvent> {
             maybeSendPlayEvent()
@@ -96,19 +96,19 @@ class NielsenHandler(
         }
         onLoadedMetadata = EventListener<LoadedMetadataEvent> {
             // contentMetadataObject contains the JSON metadata for the content being played
-            appSdk?.loadMetadata(buildMetadata())
+            appSdk.loadMetadata(buildMetadata())
         }
         onCueEnterId3 = EventListener<EnterCueEvent> { event ->
             event.cue.content?.optJSONObject("content")?.let { cueContent ->
                 handleNielsenId3Payload(cueContent) {
-                    appSdk?.sendID3(it)
+                    appSdk.sendID3(it)
                 }
             }
         }
         onCueEnterEmsg = EventListener<EnterCueEvent> { event ->
             event.cue.content?.optJSONArray("content")?.let { cueContent ->
                 handleNielsenEmsgPayload(cueContent) {
-                    appSdk?.sendID3(it)
+                    appSdk.sendID3(it)
                 }
             }
         }
@@ -128,8 +128,8 @@ class NielsenHandler(
             val ad = event.ad
             if (ad?.type == "linear") {
                 val timeOffset = ad.adBreak?.timeOffset ?: 0
-                appSdk?.stop()
-                appSdk?.loadMetadata(buildMetadata().apply {
+                appSdk.stop()
+                appSdk.loadMetadata(buildMetadata().apply {
                     put(
                         PROP_TYPE, when {
                             timeOffset == 0 -> PROP_PREROLL
@@ -144,7 +144,7 @@ class NielsenHandler(
         onAdEnd = EventListener<GoogleImaAdEvent> { event ->
             val ad = event.ad
             if (ad?.type == "linear") {
-                appSdk?.stop()
+                appSdk.stop()
             }
         }
 
@@ -170,7 +170,7 @@ class NielsenHandler(
     }
 
     fun updateMetadata(metadata: Map<String, Any>) {
-        appSdk?.loadMetadata(buildMetadata(metadata))
+        appSdk.loadMetadata(buildMetadata(metadata))
     }
 
     fun destroy() {
@@ -213,7 +213,7 @@ class NielsenHandler(
             sessionInProgress = true
 
             // stream starts
-            appSdk?.play(JSONObject().apply {
+            appSdk.play(JSONObject().apply {
                 put(PROP_CHANNEL_NAME, player.src)
             })
         }
@@ -223,7 +223,7 @@ class NielsenHandler(
         if (sessionInProgress) {
             lastPosition = -1
             sessionInProgress = false
-            appSdk?.end()
+            appSdk.end()
         }
     }
 
diff --git a/connectors/yospace/.gitignore b/connectors/yospace/.gitignore
new file mode 100644
index 00000000..42afabfd
--- /dev/null
+++ b/connectors/yospace/.gitignore
@@ -0,0 +1 @@
+/build
\ No newline at end of file
diff --git a/connectors/yospace/README.md b/connectors/yospace/README.md
new file mode 100644
index 00000000..acd09a20
--- /dev/null
+++ b/connectors/yospace/README.md
@@ -0,0 +1,55 @@
+# THEOplayer Yospace Connector for Android
+
+The Yospace connector provides a Yospace integration for THEOplayer.
+
+## Installation
+
+1. Add the THEOplayer Maven repository to your project-level `settings.gradle` file:
+   ```groovy
+   dependencyResolutionManagement {
+       repositories {
+           google()
+           mavenCentral()
+           maven { url = uri("https://maven.theoplayer.com/releases/") }
+       }
+   }
+   ```
+2. Add the Yospace Maven repository to that same `settings.gradle` file.
+   Please refer to the [Yospace Ad Management SDK documentation][yospace-userguide] (section 7.2. Downloads > Ad Management SDK) for instructions.
+3. Add THEOplayer, the Yospace Ad Management SDK and the Yospace Connector as dependencies in your module-level `build.gradle` file:
+   ```groovy
+   dependencies {
+       implementation "com.theoplayer.theoplayer-sdk-android:core:7.+"
+       implementation "com.yospace:admanagement-sdk:3.+"
+       implementation "com.theoplayer.android-connector:yospace:7.+"
+   }
+   ```
+
+## Usage
+
+First, follow [the getting started guide for the THEOplayer Android SDK][android-getting-started]
+to set up a `THEOplayerView` in your app.
+
+Then, create the `YospaceConnector`:
+
+```kotlin
+import com.theoplayer.android.api.THEOplayerView
+import com.theoplayer.android.connector.yospace.YospaceConnector
+
+val theoPlayerView = findViewById(R.id.theoplayer)
+val yospaceConnector = YospaceConnector(theoPlayerView)
+```
+
+Finally, set the THEOplayer source to a `SourceDescription` with a `YospaceSsaiDescription` as its `ssai` description:
+```kotlin
+theoplayerView.player.source = SourceDescription.Builder(
+   TypedSource.Builder("https://example.com/stream.m3u8")
+      .ssai(
+         YospaceSsaiDescription(streamType = YospaceStreamType.LIVE)
+      )
+      .build()
+).build()
+```
+
+[yospace-userguide]: https://developer.yospace.com/sdk-documentation/android/userguide/latest/en/index-en.html
+[android-getting-started]: https://www.theoplayer.com/docs/theoplayer/getting-started/sdks/android/getting-started/
diff --git a/connectors/yospace/build.gradle b/connectors/yospace/build.gradle
new file mode 100644
index 00000000..0743e5dd
--- /dev/null
+++ b/connectors/yospace/build.gradle
@@ -0,0 +1,63 @@
+import org.jetbrains.dokka.gradle.AbstractDokkaLeafTask
+
+plugins {
+    id 'com.android.library'
+    id 'org.jetbrains.kotlin.android'
+    id 'org.jetbrains.kotlin.plugin.serialization'
+    id 'org.jetbrains.dokka'
+}
+apply from: "$rootDir/connectors/publish.gradle"
+
+android {
+    namespace 'com.theoplayer.android.connector.yospace'
+    compileSdk 34
+
+    defaultConfig {
+        minSdk 21
+        consumerProguardFiles "consumer-rules.pro"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+        buildConfigField("String", "LIBRARY_VERSION", "\"${sdkVersion}\"")
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    kotlinOptions {
+        jvmTarget = '1.8'
+    }
+}
+
+dependencies {
+    implementation 'androidx.core:core-ktx:1.13.1'
+    compileOnly "com.theoplayer.theoplayer-sdk-android:core:$sdkVersion"
+    compileOnly("com.yospace:admanagement-sdk") {
+        version {
+            strictly("[3.6, 4.0)")
+            prefer(yospaceVersion)
+        }
+    }
+    implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.3"
+
+    // Tests
+    testImplementation "androidx.test:core:1.5.0"
+    testImplementation "androidx.test.ext:junit:1.1.5"
+    testImplementation "com.theoplayer.theoplayer-sdk-android:core:$sdkVersion"
+    testImplementation "com.yospace:admanagement-sdk:$yospaceVersion"
+}
+
+tasks.withType(AbstractDokkaLeafTask.class).configureEach {
+    moduleName = "Yospace Connector"
+
+    dokkaSourceSets.named("main") {
+        samples.from(project.fileTree("src/test/java/"))
+    }
+}
diff --git a/connectors/yospace/consumer-rules.pro b/connectors/yospace/consumer-rules.pro
new file mode 100644
index 00000000..e69de29b
diff --git a/connectors/yospace/proguard-rules.pro b/connectors/yospace/proguard-rules.pro
new file mode 100644
index 00000000..481bb434
--- /dev/null
+++ b/connectors/yospace/proguard-rules.pro
@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
\ No newline at end of file
diff --git a/connectors/yospace/src/main/AndroidManifest.xml b/connectors/yospace/src/main/AndroidManifest.xml
new file mode 100644
index 00000000..74b7379f
--- /dev/null
+++ b/connectors/yospace/src/main/AndroidManifest.xml
@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>
\ No newline at end of file
diff --git a/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/YospaceConnector.kt b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/YospaceConnector.kt
new file mode 100644
index 00000000..98732101
--- /dev/null
+++ b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/YospaceConnector.kt
@@ -0,0 +1,140 @@
+package com.theoplayer.android.connector.yospace
+
+import com.theoplayer.android.api.THEOplayerView
+import com.theoplayer.android.api.ads.Ad
+import com.theoplayer.android.api.ads.ServerSideAdIntegrationController
+import com.theoplayer.android.api.source.ssai.CustomSsaiDescriptionRegistry
+import com.theoplayer.android.connector.yospace.internal.YospaceAdIntegration
+import com.yospace.admanagement.AdBreak
+import com.yospace.admanagement.Advert
+import com.yospace.admanagement.AnalyticEventObserver
+import com.yospace.admanagement.Session
+import com.yospace.admanagement.TrackingErrors
+import java.util.concurrent.CopyOnWriteArrayList
+
+internal const val TAG = "YospaceConnector"
+internal const val USER_AGENT = "THEOplayerYospaceConnector/${BuildConfig.LIBRARY_VERSION}"
+
+/**
+ * A connector for the Yospace Ad Management SDK.
+ *
+ * @param theoplayerView
+ *   The THEOplayer view, which will be connected to the created connector.
+ * @param uiHandler
+ *   A handler for updating the UI. By default, this creates a [YospaceDefaultUiHandler].
+ *
+ * @sample com.theoplayer.android.connector.yospace.samples.createYospaceConnector
+ *
+ * @see [Yospace Ad Management SDK v3 for Android Developers](https://developer.yospace.com/sdk-documentation/android/userguide/latest/en/index-en.html)
+ *      (requires login)
+ */
+class YospaceConnector @JvmOverloads constructor(
+    private val theoplayerView: THEOplayerView,
+    private val uiHandler: YospaceUiHandler = YospaceDefaultUiHandler(theoplayerView)
+) {
+    private val analyticEventObservers = CopyOnWriteArrayList<AnalyticEventObserver>()
+    private val listeners = CopyOnWriteArrayList<YospaceListener>()
+
+    private lateinit var integration: YospaceAdIntegration
+
+    init {
+        theoplayerView.player.ads.registerServerSideIntegration(INTEGRATION_ID, this::setupIntegration)
+    }
+
+    private fun setupIntegration(controller: ServerSideAdIntegrationController): YospaceAdIntegration {
+        val integration = YospaceAdIntegration(
+            theoplayerView,
+            uiHandler,
+            controller,
+            ForwardingAnalyticEventObserver(),
+            ForwardingListener()
+        )
+        this.integration = integration
+        return integration
+    }
+
+    /**
+     * Registers an [AnalyticEventObserver] on the Yospace [Session].
+     */
+    fun registerAnalyticEventObserver(observer: AnalyticEventObserver) {
+        analyticEventObservers.add(observer)
+    }
+
+    /**
+     * Removes a previously registered [AnalyticEventObserver].
+     */
+    fun unregisterAnalyticEventObserver(observer: AnalyticEventObserver) {
+        analyticEventObservers.remove(observer)
+    }
+
+    /**
+     * Registers a [YospaceListener] to receive events from this connector.
+     */
+    fun addListener(listener: YospaceListener) {
+        listeners.add(listener)
+    }
+
+    /**
+     * Removes a previously registered [YospaceListener].
+     */
+    fun removeListener(listener: YospaceListener) {
+        listeners.remove(listener)
+    }
+
+    private inner class ForwardingAnalyticEventObserver : AnalyticEventObserver {
+        override fun onAdvertBreakStart(adBreak: AdBreak?, session: Session) {
+            analyticEventObservers.forEach { it.onAdvertBreakStart(adBreak, session) }
+        }
+
+        override fun onAdvertBreakEnd(session: Session) {
+            analyticEventObservers.forEach { it.onAdvertBreakEnd(session) }
+        }
+
+        override fun onAdvertStart(advert: Advert, session: Session) {
+            analyticEventObservers.forEach { it.onAdvertStart(advert, session) }
+        }
+
+        override fun onAdvertEnd(session: Session) {
+            analyticEventObservers.forEach { it.onAdvertEnd(session) }
+        }
+
+        override fun onAnalyticUpdate(session: Session) {
+            analyticEventObservers.forEach { it.onAnalyticUpdate(session) }
+        }
+
+        override fun onEarlyReturn(adBreak: AdBreak, session: Session) {
+            analyticEventObservers.forEach { it.onEarlyReturn(adBreak, session) }
+        }
+
+        override fun onSessionError(error: AnalyticEventObserver.SessionError, session: Session) {
+            analyticEventObservers.forEach { it.onSessionError(error, session) }
+        }
+
+        override fun onTrackingEvent(type: String, session: Session) {
+            analyticEventObservers.forEach { it.onTrackingEvent(type, session) }
+        }
+
+        override fun onTrackingError(error: TrackingErrors.Error, session: Session) {
+            analyticEventObservers.forEach { it.onTrackingError(error, session) }
+        }
+    }
+
+    private inner class ForwardingListener : YospaceListener {
+        override fun onSessionAvailable() {
+            listeners.forEach { it.onSessionAvailable() }
+        }
+    }
+
+    companion object {
+        /**
+         * The integration identifier for the Yospace connector.
+         *
+         * Ads created by this connector have this value as their [custom integration][Ad.getCustomIntegration].
+         */
+        const val INTEGRATION_ID = "yospace"
+
+        init {
+            CustomSsaiDescriptionRegistry.register(INTEGRATION_ID, YospaceSsaiDescriptionSerializer())
+        }
+    }
+}
diff --git a/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/YospaceDefaultUiHandler.kt b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/YospaceDefaultUiHandler.kt
new file mode 100644
index 00000000..9077bfd3
--- /dev/null
+++ b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/YospaceDefaultUiHandler.kt
@@ -0,0 +1,102 @@
+package com.theoplayer.android.connector.yospace
+
+import android.graphics.BitmapFactory
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.Button
+import android.widget.ImageView
+import com.theoplayer.android.api.THEOplayerView
+import com.yospace.admanagement.LinearCreative
+import com.yospace.admanagement.NonLinearCreative
+import com.yospace.admanagement.Resource
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.net.URL
+
+/**
+ * A default UI handler for the Yospace connector.
+ *
+ * This handler shows a linear clickthrough button in the top-right corner,
+ * and shows clickable non-linear images in the top-left corner.
+ *
+ * If you want to customize the UI, you can implement your own [YospaceUiHandler]
+ * and pass it to the [YospaceConnector] constructor.
+ */
+class YospaceDefaultUiHandler(
+    theoplayerView: THEOplayerView
+) : YospaceUiHandler {
+    private val parentView: ViewGroup = theoplayerView.findViewById(R.id.theo_ads_container)
+    private val adsContainer: ViewGroup =
+        (LayoutInflater.from(parentView.context).inflate(R.layout.default_ad_overlay, parentView, false) as ViewGroup).also {
+            parentView.addView(it)
+        }
+    private val linearClickThroughButton = adsContainer.findViewById<Button>(R.id.theo_yospace_linear_clickthrough).apply {
+        visibility = View.GONE
+    }
+    private val nonLinearContainer = adsContainer.findViewById<ViewGroup>(R.id.theo_yospace_nonlinear).apply {
+        visibility = View.GONE
+    }
+    private val nonLinearLoadJobs: MutableMap<NonLinearCreative, NonLinearUiState> = mutableMapOf()
+    private val scope = CoroutineScope(Dispatchers.Main)
+
+    override fun showLinearClickThrough(linearCreative: LinearCreative, callback: YospaceClickThroughCallback) {
+        linearClickThroughButton.run {
+            setOnClickListener { callback.onClickThrough(context) }
+            visibility = View.VISIBLE
+        }
+    }
+
+    override fun hideLinearClickThrough() {
+        linearClickThroughButton.run {
+            setOnClickListener(null)
+            visibility = View.GONE
+        }
+    }
+
+    override fun showNonLinear(nonLinearCreative: NonLinearCreative, callback: YospaceClickThroughCallback) {
+        val imageUrl = nonLinearCreative.getResource(Resource.ResourceType.STATIC)?.stringData ?: return
+        val imageView = ImageView(parentView.context).apply {
+            layoutParams = ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, resources.getDimensionPixelSize(R.dimen.nonlinear_height))
+            scaleType = ImageView.ScaleType.FIT_START
+            contentDescription = resources.getString(R.string.txt_ad)
+            visibility = View.GONE
+            setOnClickListener { callback.onClickThrough(context) }
+        }
+        val loadJob = scope.launch {
+            ensureActive()
+            val imageBitmap = withContext(Dispatchers.IO) {
+                URL(imageUrl).openStream().use { BitmapFactory.decodeStream(it) }
+            }
+            ensureActive()
+            imageView.run {
+                setImageBitmap(imageBitmap)
+                visibility = View.VISIBLE
+            }
+        }
+        nonLinearLoadJobs[nonLinearCreative] = NonLinearUiState(imageView = imageView, loadJob = loadJob)
+    }
+
+    override fun hideNonLinear(nonLinearCreative: NonLinearCreative) {
+        nonLinearLoadJobs.remove(nonLinearCreative)?.let {
+            it.loadJob.cancel()
+            nonLinearContainer.removeView(it.imageView)
+        }
+    }
+
+    override fun destroy() {
+        scope.cancel()
+        adsContainer.removeAllViews()
+        parentView.removeView(adsContainer)
+    }
+}
+
+private class NonLinearUiState(
+    val imageView: ImageView,
+    val loadJob: Job
+)
\ No newline at end of file
diff --git a/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/YospaceListener.kt b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/YospaceListener.kt
new file mode 100644
index 00000000..8533e3a3
--- /dev/null
+++ b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/YospaceListener.kt
@@ -0,0 +1,11 @@
+package com.theoplayer.android.connector.yospace
+
+/**
+ * A listener that receives events from a [YospaceConnector].
+ */
+interface YospaceListener {
+    /**
+     * Fired when a new Yospace session starts.
+     */
+    fun onSessionAvailable() {}
+}
\ No newline at end of file
diff --git a/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/YospaceSsaiDescription.kt b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/YospaceSsaiDescription.kt
new file mode 100644
index 00000000..9bd3c5de
--- /dev/null
+++ b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/YospaceSsaiDescription.kt
@@ -0,0 +1,125 @@
+package com.theoplayer.android.connector.yospace
+
+import com.theoplayer.android.api.source.ssai.CustomSsaiDescription
+import com.theoplayer.android.api.source.ssai.CustomSsaiDescriptionSerializer
+import com.theoplayer.android.connector.yospace.internal.SerializedSessionProperties
+import com.theoplayer.android.connector.yospace.internal.deserialize
+import com.theoplayer.android.connector.yospace.internal.serialize
+import com.yospace.admanagement.Session
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.json.Json
+
+/**
+ * The configuration for server-side ad insertion using the [YospaceConnector].
+ */
+class YospaceSsaiDescription @JvmOverloads constructor(
+    /**
+     * The type of the requested stream.
+     *
+     * Default: [YospaceStreamType.LIVE]
+     */
+    val streamType: YospaceStreamType = YospaceStreamType.LIVE,
+    /**
+     * Custom properties to set when initializing the Yospace session.
+     */
+    val sessionProperties: Session.SessionProperties = Session.SessionProperties()
+) : CustomSsaiDescription() {
+    override val customIntegration: String
+        get() = YospaceConnector.INTEGRATION_ID
+
+    /**
+     * A builder for a [YospaceSsaiDescription].
+     */
+    class Builder() {
+        private var streamType: YospaceStreamType = YospaceStreamType.LIVE
+        private var sessionProperties: Session.SessionProperties = Session.SessionProperties()
+
+        /**
+         * Sets the type of the requested stream.
+         */
+        fun streamType(streamType: YospaceStreamType) = apply { this.streamType = streamType }
+
+        /**
+         * Sets the custom properties to set when initializing the Yospace session.
+         */
+        fun sessionProperties(sessionProperties: Session.SessionProperties) = apply { this.sessionProperties = sessionProperties }
+
+        /**
+         * Builds the [YospaceSsaiDescription].
+         */
+        fun build() = YospaceSsaiDescription(streamType = streamType, sessionProperties = sessionProperties)
+    }
+}
+
+/**
+ * The type of the Yospace stream.
+ */
+enum class YospaceStreamType {
+    /**
+     * The stream is a live stream.
+     */
+    LIVE,
+
+    /**
+     * The stream is a live stream with a large DVR window.
+     */
+    LIVEPAUSE,
+
+    /**
+     * The stream is a Non-Linear Start-Over stream.
+     */
+    NONLINEAR,
+
+    /**
+     * The stream is a video-on-demand stream.
+     */
+    VOD,
+}
+
+internal class YospaceSsaiDescriptionSerializer : CustomSsaiDescriptionSerializer {
+    override fun fromJson(json: String): YospaceSsaiDescription {
+        return Json.decodeFromString(YospaceSsaiDescriptionKSerializer(), json)
+    }
+
+    override fun toJson(value: CustomSsaiDescription): String {
+        return Json.encodeToString(YospaceSsaiDescriptionKSerializer(), value as YospaceSsaiDescription)
+    }
+}
+
+@Serializable
+private data class SerializedYospaceSsaiDescription(
+    val integration: String,
+    val streamType: YospaceStreamType,
+    val sessionProperties: SerializedSessionProperties
+)
+
+private fun YospaceSsaiDescription.serialize() = SerializedYospaceSsaiDescription(
+    integration = customIntegration,
+    streamType = streamType,
+    sessionProperties = sessionProperties.serialize()
+)
+
+private fun SerializedYospaceSsaiDescription.deserialize() = YospaceSsaiDescription(
+    streamType = streamType,
+    sessionProperties = sessionProperties.deserialize()
+)
+
+private class YospaceSsaiDescriptionKSerializer : KSerializer<YospaceSsaiDescription> {
+    private val delegateSerializer = SerializedYospaceSsaiDescription.serializer()
+
+    @OptIn(ExperimentalSerializationApi::class)
+    override val descriptor = SerialDescriptor("YospaceSsaiDescription", delegateSerializer.descriptor)
+
+    override fun serialize(encoder: Encoder, value: YospaceSsaiDescription) {
+        encoder.encodeSerializableValue(delegateSerializer, value.serialize())
+    }
+
+    override fun deserialize(decoder: Decoder): YospaceSsaiDescription {
+        return decoder.decodeSerializableValue(delegateSerializer).deserialize()
+    }
+}
diff --git a/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/YospaceUiHandler.kt b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/YospaceUiHandler.kt
new file mode 100644
index 00000000..6e563d82
--- /dev/null
+++ b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/YospaceUiHandler.kt
@@ -0,0 +1,64 @@
+package com.theoplayer.android.connector.yospace
+
+import android.app.Activity
+import android.content.Context
+import com.theoplayer.android.api.THEOplayerView
+import com.yospace.admanagement.LinearCreative
+import com.yospace.admanagement.NonLinearCreative
+
+/**
+ * A callback that should be called when a linear or non-linear creative is clicked.
+ *
+ * @see YospaceUiHandler.showLinearClickThrough
+ * @see YospaceUiHandler.hideLinearClickThrough
+ */
+fun interface YospaceClickThroughCallback {
+    /**
+     * Called when the creative is clicked.
+     *
+     * @param context The context of the calling [Activity].
+     */
+    fun onClickThrough(context: Context)
+}
+
+/**
+ * A UI handler for the Yospace connector.
+ *
+ * This handler is called whenever a linear clickthrough or non-linear ad needs to be shown
+ * to the user.
+ *
+ * All methods are always called from the main thread.
+ */
+interface YospaceUiHandler {
+    /**
+     * Called when a click-through button for the given linear creative should be shown.
+     *
+     * @param linearCreative The linear creative.
+     * @param callback The callback to call when the click-through button is clicked.
+     */
+    fun showLinearClickThrough(linearCreative: LinearCreative, callback: YospaceClickThroughCallback)
+
+    /**
+     * Called when the click-through button for the current linear creative should be removed.
+     */
+    fun hideLinearClickThrough()
+
+    /**
+     * Called when the given non-linear creative should be shown.
+     *
+     * @param nonLinearCreative The non-linear creative.
+     * @param callback The callback to call when the non-linear creative is clicked.
+     */
+    fun showNonLinear(nonLinearCreative: NonLinearCreative, callback: YospaceClickThroughCallback)
+
+    /**
+     * Called when the given non-linear creative should be removed.
+     */
+    fun hideNonLinear(nonLinearCreative: NonLinearCreative)
+
+    /**
+     * Called when the player is [destroyed][THEOplayerView.isDestroyed],
+     * to clean up any created resources.
+     */
+    fun destroy()
+}
\ No newline at end of file
diff --git a/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/AdHandler.kt b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/AdHandler.kt
new file mode 100644
index 00000000..56e53ad9
--- /dev/null
+++ b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/AdHandler.kt
@@ -0,0 +1,168 @@
+package com.theoplayer.android.connector.yospace.internal
+
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import com.theoplayer.android.api.ads.Ad
+import com.theoplayer.android.api.ads.AdBreak
+import com.theoplayer.android.api.ads.AdBreakInit
+import com.theoplayer.android.api.ads.AdInit
+import com.theoplayer.android.api.ads.ServerSideAdIntegrationController
+import com.theoplayer.android.api.player.Player
+import com.theoplayer.android.connector.yospace.YospaceUiHandler
+import com.yospace.admanagement.AnalyticEventObserver
+import com.yospace.admanagement.Creative
+import com.yospace.admanagement.Resource
+import com.yospace.admanagement.Session
+import com.yospace.admanagement.TrackingErrors
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import java.util.WeakHashMap
+import com.yospace.admanagement.AdBreak as YospaceAdBreak
+import com.yospace.admanagement.Advert as YospaceAdvert
+
+internal class AdHandler(
+    private val player: Player,
+    private val controller: ServerSideAdIntegrationController,
+    private val uiHandler: YospaceUiHandler,
+    private val playheadConverter: PlayheadConverter
+) : AnalyticEventObserver {
+    private val ads: WeakHashMap<YospaceAdvert, Ad> = WeakHashMap()
+    private val adBreaks: WeakHashMap<YospaceAdBreak, AdBreak> = WeakHashMap()
+    private var currentAd: Ad? = null
+    private var currentYospaceAdvert: YospaceAdvert? = null
+    private var currentAdBreak: AdBreak? = null
+    private val uiScope = CoroutineScope(Dispatchers.Main)
+
+    private fun getOrCreateAdBreak(yospaceAdBreak: YospaceAdBreak): AdBreak {
+        val adBreak = adBreaks.getOrPut(yospaceAdBreak) { controller.createAdBreak(getAdBreakInit(yospaceAdBreak)) }
+        yospaceAdBreak.adverts.forEach { getOrCreateAd(it, adBreak) }
+        return adBreak
+    }
+
+    private fun getAdBreakInit(yospaceAdBreak: YospaceAdBreak): AdBreakInit {
+        return AdBreakInit(
+            timeOffset = playheadConverter.fromPlayhead(yospaceAdBreak.start).toInt(),
+            maxDuration = yospaceAdBreak.duration / 1000
+        )
+    }
+
+    private fun getOrCreateAd(yospaceAdvert: YospaceAdvert, adBreak: AdBreak): Ad {
+        var update = true
+        val ad = ads.getOrPut(yospaceAdvert) {
+            update = false
+            controller.createAd(getAdInit(yospaceAdvert), adBreak)
+        }
+        if (update) {
+            controller.updateAd(ad, getAdInit(yospaceAdvert))
+        }
+        return ad
+    }
+
+    private fun getAdInit(advert: YospaceAdvert): AdInit {
+        val nonLinearCreative = if (advert.isNonLinear) advert.getNonLinearCreatives(Resource.ResourceType.STATIC).firstOrNull() else null
+        return AdInit(
+            type = if (advert.isNonLinear) "nonlinear" else "linear",
+            skipOffset = if (advert.skipOffset < 0) -1 else (advert.skipOffset / 1000).toInt(),
+            id = advert.identifier,
+            duration = (advert.duration / 1000).toInt(),
+            clickThrough = if (advert.isNonLinear) nonLinearCreative?.clickThroughUrl else advert.linearCreative?.clickThroughUrl,
+            resourceURI = nonLinearCreative?.getResource(Resource.ResourceType.STATIC)?.stringData
+        )
+    }
+
+    override fun onAdvertBreakStart(adBreak: YospaceAdBreak?, session: Session) {
+        currentAdBreak = if (adBreak == null) {
+            // During live playback, an ad break may be started without any information
+            controller.createAdBreak(AdBreakInit(timeOffset = player.currentTime.toInt()))
+        } else {
+            getOrCreateAdBreak(adBreak)
+        }
+    }
+
+    override fun onAdvertBreakEnd(session: Session) {
+        currentAdBreak?.let {
+            controller.removeAdBreak(it)
+            currentAdBreak = null
+        }
+    }
+
+    override fun onAdvertStart(advert: YospaceAdvert, session: Session) {
+        val ad = getOrCreateAd(advert, currentAdBreak ?: return)
+        currentAd = ad
+        currentYospaceAdvert = advert
+        controller.beginAd(ad)
+
+        uiScope.launch {
+            advert.linearCreative?.let { creative ->
+                uiHandler.showLinearClickThrough(creative) { context -> onCreativeClickThrough(context, creative, creative.clickThroughUrl) }
+            }
+            advert.getNonLinearCreatives(Resource.ResourceType.STATIC).forEach { creative ->
+                uiHandler.showNonLinear(creative) { context -> onCreativeClickThrough(context, creative, creative.clickThroughUrl) }
+            }
+        }
+    }
+
+    private fun onCreativeClickThrough(context: Context, creative: Creative, clickThroughUrl: String) {
+        uiScope.launch {
+            // Pause the player
+            player.pause()
+
+            // Notify SDK
+            creative.onClickThrough()
+
+            // Open click-through URL in browser
+            val intent = Intent(Intent.ACTION_VIEW).apply {
+                setData(Uri.parse(clickThroughUrl))
+            }
+            context.startActivity(intent)
+        }
+    }
+
+    override fun onAdvertEnd(session: Session) {
+        currentYospaceAdvert?.let {
+            uiScope.launch {
+                it.linearCreative?.let { uiHandler.hideLinearClickThrough() }
+                it.getNonLinearCreatives(Resource.ResourceType.STATIC).forEach { uiHandler.hideNonLinear(it) }
+            }
+            currentYospaceAdvert = null
+        }
+        currentAd?.let {
+            controller.endAd(it)
+            currentAd = null
+        }
+    }
+
+    override fun onEarlyReturn(adBreak: YospaceAdBreak, session: Session) {
+        currentAd?.let {
+            controller.skipAd(it)
+            currentAd = null
+            currentYospaceAdvert = null
+        }
+        onAdvertBreakEnd(session)
+    }
+
+    override fun onAnalyticUpdate(session: Session) {}
+
+    override fun onSessionError(error: AnalyticEventObserver.SessionError, session: Session) {}
+
+    override fun onTrackingEvent(type: String, session: Session) {}
+
+    override fun onTrackingError(error: TrackingErrors.Error, session: Session) {}
+
+    fun onTimeUpdate(playhead: Long) {
+        val ad = this.currentAd ?: return
+        val advert = this.currentYospaceAdvert ?: return
+        val duration = advert.duration
+        val remainingTime = advert.getRemainingTime(playhead)
+        val progress = ((duration - remainingTime).toDouble() / duration.toDouble()).coerceIn(0.0, 1.0)
+        controller.updateAdProgress(ad, progress)
+    }
+
+    fun destroy() {
+        controller.removeAllAds()
+        uiScope.cancel()
+    }
+}
\ No newline at end of file
diff --git a/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/PlayheadConverter.kt b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/PlayheadConverter.kt
new file mode 100644
index 00000000..503d3e88
--- /dev/null
+++ b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/PlayheadConverter.kt
@@ -0,0 +1,7 @@
+package com.theoplayer.android.connector.yospace.internal
+
+internal interface PlayheadConverter {
+    fun fromPlayhead(playhead: Long): Double
+
+    fun toPlayhead(playerTime: Double): Long
+}
\ No newline at end of file
diff --git a/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/SessionPropertiesUtil.kt b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/SessionPropertiesUtil.kt
new file mode 100644
index 00000000..3b5320ae
--- /dev/null
+++ b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/SessionPropertiesUtil.kt
@@ -0,0 +1,82 @@
+package com.theoplayer.android.connector.yospace.internal
+
+import com.yospace.admanagement.Session
+import kotlinx.serialization.Serializable
+import java.util.UUID
+
+internal fun Session.SessionProperties.copy(
+    requestTimeout: Int = this.requestTimeout,
+    resourceTimeout: Int = this.resourceTimeout,
+    userAgent: String = this.userAgent,
+    proxyUserAgent: String = this.proxyUserAgent,
+    keepProxyAlive: Boolean = this.keepProxyAlive,
+    prefetchResources: Boolean = this.prefetchResources,
+    fireHistoricalBeacons: Boolean = this.fireHistoricalBeacons,
+    applyEncryptedTracking: Boolean = this.applyEncryptedTracking,
+    excludedCategories: Int = this.excludedCategories,
+    consecutiveBreakTolerance: Int = this.consecutiveBreakTolerance,
+    token: UUID = this.token,
+    customHttpHeaders: Map<String, String> = this.customHttpHeaders,
+) = Session.SessionProperties().apply {
+    this.requestTimeout = requestTimeout
+    this.resourceTimeout = resourceTimeout
+    this.userAgent = userAgent
+    this.proxyUserAgent = proxyUserAgent
+    this.keepProxyAlive = keepProxyAlive
+    this.prefetchResources = prefetchResources
+    this.fireHistoricalBeacons = fireHistoricalBeacons
+    this.applyEncryptedTracking = applyEncryptedTracking
+    this.excludeFromSuppression(excludedCategories)
+    this.consecutiveBreakTolerance = consecutiveBreakTolerance
+    this.token = token
+    this.customHttpHeaders = customHttpHeaders
+}
+
+@Serializable
+internal data class SerializedSessionProperties(
+    val requestTimeout: Int,
+    val resourceTimeout: Int,
+    val userAgent: String,
+    val proxyUserAgent: String,
+    val keepProxyAlive: Boolean,
+    val prefetchResources: Boolean,
+    val fireHistoricalBeacons: Boolean,
+    val applyEncryptedTracking: Boolean,
+    val excludedCategories: Int,
+    val consecutiveBreakTolerance: Int,
+    val token: String,
+    val customHttpHeaders: Map<String, String>,
+)
+
+internal fun Session.SessionProperties.serialize() = SerializedSessionProperties(
+    requestTimeout = requestTimeout,
+    resourceTimeout = resourceTimeout,
+    userAgent = userAgent,
+    proxyUserAgent = proxyUserAgent,
+    keepProxyAlive = keepProxyAlive,
+    prefetchResources = prefetchResources,
+    fireHistoricalBeacons = fireHistoricalBeacons,
+    applyEncryptedTracking = applyEncryptedTracking,
+    excludedCategories = excludedCategories,
+    consecutiveBreakTolerance = consecutiveBreakTolerance,
+    token = token.toString(),
+    customHttpHeaders = customHttpHeaders,
+)
+
+internal fun SerializedSessionProperties.deserialize(): Session.SessionProperties {
+    val serialized = this
+    return Session.SessionProperties().apply {
+        requestTimeout = serialized.requestTimeout
+        resourceTimeout = serialized.resourceTimeout
+        userAgent = serialized.userAgent
+        proxyUserAgent = serialized.proxyUserAgent
+        keepProxyAlive = serialized.keepProxyAlive
+        prefetchResources = serialized.prefetchResources
+        fireHistoricalBeacons = serialized.fireHistoricalBeacons
+        applyEncryptedTracking = serialized.applyEncryptedTracking
+        excludeFromSuppression(serialized.excludedCategories)
+        consecutiveBreakTolerance = serialized.consecutiveBreakTolerance
+        token = UUID.fromString(serialized.token)
+        customHttpHeaders = serialized.customHttpHeaders
+    }
+}
\ No newline at end of file
diff --git a/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/SourceHelpers.kt b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/SourceHelpers.kt
new file mode 100644
index 00000000..9e03e49f
--- /dev/null
+++ b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/SourceHelpers.kt
@@ -0,0 +1,28 @@
+package com.theoplayer.android.connector.yospace.internal
+
+import com.theoplayer.android.api.source.SourceDescription
+import com.theoplayer.android.api.source.TypedSource
+
+internal fun SourceDescription.replaceSources(sources: List<TypedSource>): SourceDescription {
+    return SourceDescription.Builder(*sources.toTypedArray()).apply {
+        ads(*ads.toTypedArray())
+        textTracks(*textTracks.toTypedArray())
+        poster?.let { poster(it) }
+        metadata?.let { metadata(it) }
+        timeServer?.let { timeServer(it) }
+    }.build()
+}
+
+internal fun TypedSource.replaceSrc(src: String): TypedSource {
+    return TypedSource.Builder(src).apply {
+        drm?.let { drm(it) }
+        type?.let { type(it) }
+        liveOffset?.let { liveOffset(it) }
+        ssai?.let { ssai(it) }
+        isHlsDateRange?.let { hlsDateRange(it) }
+        timeServer?.let { timeServer(it) }
+        isLowLatency?.let { lowLatency(it) }
+        hls?.let { hls(it) }
+        dash?.let { dash(it) }
+    }.build()
+}
\ No newline at end of file
diff --git a/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/TimedMetadataHandler.kt b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/TimedMetadataHandler.kt
new file mode 100644
index 00000000..8b661aaa
--- /dev/null
+++ b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/TimedMetadataHandler.kt
@@ -0,0 +1,156 @@
+package com.theoplayer.android.connector.yospace.internal
+
+import com.theoplayer.android.api.event.EventListener
+import com.theoplayer.android.api.event.track.texttrack.CueChangeEvent
+import com.theoplayer.android.api.event.track.texttrack.TextTrackEventTypes
+import com.theoplayer.android.api.event.track.texttrack.list.AddTrackEvent
+import com.theoplayer.android.api.event.track.texttrack.list.RemoveTrackEvent
+import com.theoplayer.android.api.event.track.texttrack.list.TextTrackListEventTypes
+import com.theoplayer.android.api.player.Player
+import com.theoplayer.android.api.player.track.texttrack.TextTrack
+import com.theoplayer.android.api.player.track.texttrack.TextTrackType
+import com.theoplayer.android.api.player.track.texttrack.cue.TextTrackCue
+import org.json.JSONArray
+
+private const val YOSPACE_EMSG_SCHEME_ID_URI = "urn:yospace:a:id3:2016";
+
+internal class TimedMetadataHandler(
+    private val player: Player,
+    private val callback: TimedMetadataCallback
+) {
+    private fun handleTrackAdded(track: TextTrack) {
+        if (track.kind != "metadata") {
+            return
+        }
+        when (track.type) {
+            TextTrackType.ID3 -> {
+                handleId3CueChange(track)
+                track.addEventListener(TextTrackEventTypes.CUECHANGE, onId3CueChange)
+            }
+
+            TextTrackType.EMSG -> {
+                handleEmsgCueChange(track)
+                track.addEventListener(TextTrackEventTypes.CUECHANGE, onEmsgCueChange)
+            }
+
+            else -> return
+        }
+    }
+
+    private fun handleTrackRemoved(track: TextTrack) {
+        track.removeEventListener(TextTrackEventTypes.CUECHANGE, onId3CueChange)
+        track.removeEventListener(TextTrackEventTypes.CUECHANGE, onEmsgCueChange)
+    }
+
+    private fun handleId3CueChange(track: TextTrack) {
+        val activeCues = (track.activeCues ?: return).filter(::isYospaceId3Cue)
+        var startTime = (activeCues.firstOrNull() ?: return).startTime
+        var report = PendingTimedMetadata()
+        for (cue in activeCues) {
+            if (cue.startTime != startTime) {
+                finishReport(report, startTime)
+                report = PendingTimedMetadata()
+            }
+            // cue.content.content is an ID3 frame encoded as a JSON object.
+            // See `ID3Yospace` in THEOplayer Web SDK for the full type definition.
+            val id3 = cue.content!!.getJSONObject("content")
+            report.update(id3.getString("id"), id3.optString("text"))
+            startTime = cue.startTime
+        }
+        finishReport(report, startTime)
+    }
+
+    private fun handleEmsgCueChange(track: TextTrack) {
+        val activeCues = (track.activeCues ?: return).filter(::isYospaceEmsgCue)
+        for (cue in activeCues) {
+            val report = PendingTimedMetadata()
+            // cue.content.content is a byte array of a UTF-8 encoded string
+            // holding comma-separated `key=value` pairs.
+            val text = jsonArrayToByteArray(cue.content!!.getJSONArray("content")).toString(Charsets.UTF_8)
+            for (pair in text.splitToSequence(',')) {
+                val (key, value) = pair.split('=', limit = 2)
+                report.update(key, value)
+                finishReport(report, cue.startTime)
+            }
+        }
+    }
+
+    private fun finishReport(report: PendingTimedMetadata, startTime: Double) {
+        report.finish()?.let { metadata -> callback.onTimedMetadata(metadata, startTime) }
+    }
+
+    private val onAddTrack = EventListener<AddTrackEvent> { handleTrackAdded(it.track) }
+    private val onRemoveTrack = EventListener<RemoveTrackEvent> { handleTrackRemoved(it.track) }
+    private val onId3CueChange = EventListener<CueChangeEvent> { handleId3CueChange(it.textTrack) }
+    private val onEmsgCueChange = EventListener<CueChangeEvent> { handleEmsgCueChange(it.textTrack) }
+
+    init {
+        player.textTracks.forEach { handleTrackAdded(it) }
+        player.textTracks.addEventListener(TextTrackListEventTypes.ADDTRACK, onAddTrack)
+        player.textTracks.addEventListener(TextTrackListEventTypes.REMOVETRACK, onRemoveTrack)
+    }
+
+    fun destroy() {
+        player.textTracks.forEach { handleTrackRemoved(it) }
+        player.textTracks.removeEventListener(TextTrackListEventTypes.ADDTRACK, onAddTrack)
+        player.textTracks.removeEventListener(TextTrackListEventTypes.REMOVETRACK, onRemoveTrack)
+    }
+}
+
+private data class PendingTimedMetadata(
+    var ymid: String? = null,
+    var ytyp: String? = null,
+    var yseq: String? = null,
+    var ydur: String? = null,
+) {
+    fun update(key: String, value: String?) {
+        when (key.uppercase()) {
+            "YMID" -> ymid = value
+            "YTYP" -> ytyp = value
+            "YSEQ" -> yseq = value
+            "YDUR" -> ydur = value
+        }
+    }
+
+    fun finish(): TimedMetadata? {
+        val (ymid, ytyp, yseq, ydur) = this
+        // Only create complete reports
+        return if (ymid != null && ydur != null && yseq != null && ytyp != null) {
+            TimedMetadata(ymid = ymid, yseq = yseq, ytyp = ytyp, ydur = ydur)
+        } else {
+            null
+        }
+    }
+}
+
+internal data class TimedMetadata(
+    val ymid: String,
+    val ytyp: String,
+    val yseq: String,
+    val ydur: String,
+)
+
+internal fun interface TimedMetadataCallback {
+    fun onTimedMetadata(yospaceMetadata: TimedMetadata, startTime: Double)
+}
+
+private fun isYospaceId3Cue(cue: TextTrackCue): Boolean {
+    val id3 = cue.content?.optJSONObject("content") ?: return false
+    return when (id3.optString("id")) {
+        "YMID", "YTYP", "YSEQ", "YDUR" -> true
+        else -> false
+    }
+}
+
+private fun isYospaceEmsgCue(cue: TextTrackCue): Boolean {
+    // FIXME Check if cue.schemeIdUri == YOSPACE_EMSG_SCHEME_ID_URI
+    return cue.content?.optJSONArray("content") != null
+}
+
+private fun jsonArrayToByteArray(jsonArray: JSONArray): ByteArray {
+    val result = ByteArray(jsonArray.length())
+    for (i in 0..<jsonArray.length()) {
+        result[i] = jsonArray.getInt(i).toByte()
+    }
+    return result
+}
\ No newline at end of file
diff --git a/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/YospaceAdIntegration.kt b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/YospaceAdIntegration.kt
new file mode 100644
index 00000000..f00414f9
--- /dev/null
+++ b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/YospaceAdIntegration.kt
@@ -0,0 +1,336 @@
+package com.theoplayer.android.connector.yospace.internal
+
+import android.util.Log
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import com.theoplayer.android.api.THEOplayerView
+import com.theoplayer.android.api.ads.ServerSideAdIntegrationController
+import com.theoplayer.android.api.ads.ServerSideAdIntegrationHandler
+import com.theoplayer.android.api.event.Event
+import com.theoplayer.android.api.event.EventListener
+import com.theoplayer.android.api.event.player.EndedEvent
+import com.theoplayer.android.api.event.player.PauseEvent
+import com.theoplayer.android.api.event.player.PlayEvent
+import com.theoplayer.android.api.event.player.PlayerEventTypes
+import com.theoplayer.android.api.event.player.PlayingEvent
+import com.theoplayer.android.api.event.player.SeekedEvent
+import com.theoplayer.android.api.event.player.TimeUpdateEvent
+import com.theoplayer.android.api.event.player.VolumeChangeEvent
+import com.theoplayer.android.api.event.player.WaitingEvent
+import com.theoplayer.android.api.player.Player
+import com.theoplayer.android.api.source.SourceDescription
+import com.theoplayer.android.connector.yospace.TAG
+import com.theoplayer.android.connector.yospace.USER_AGENT
+import com.theoplayer.android.connector.yospace.YospaceListener
+import com.theoplayer.android.connector.yospace.YospaceSsaiDescription
+import com.theoplayer.android.connector.yospace.YospaceStreamType
+import com.theoplayer.android.connector.yospace.YospaceUiHandler
+import com.yospace.admanagement.AnalyticEventObserver
+import com.yospace.admanagement.PlaybackEventHandler
+import com.yospace.admanagement.Session
+import com.yospace.admanagement.SessionDVRLive
+import com.yospace.admanagement.SessionLive
+import com.yospace.admanagement.SessionVOD
+import com.yospace.admanagement.TimedMetadata
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
+internal class YospaceAdIntegration(
+    private val theoplayerView: THEOplayerView,
+    private val uiHandler: YospaceUiHandler,
+    private val controller: ServerSideAdIntegrationController,
+    private val analyticEventObserver: AnalyticEventObserver,
+    private val listener: YospaceListener
+) : ServerSideAdIntegrationHandler, PlayheadConverter, DefaultLifecycleObserver {
+
+    private var sourceWithYospace: SourceDescription? = null
+    private var session: Session? = null
+    private var timedMetadataHandler: TimedMetadataHandler? = null
+    private var adHandler: AdHandler? = null
+
+    private var didFirstPlay: Boolean = false
+    private var streamStart: Double? = null
+    private var isMuted: Boolean = false
+    private var isStalling: Boolean = false
+    private var wasPlaying: Boolean = false
+
+    private val player: Player
+        get() = theoplayerView.player
+
+    private val currentPlayhead: Long
+        get() = toPlayhead(player.currentTime)
+
+    private val lifecycle: Lifecycle?
+        get() = (theoplayerView.context as? LifecycleOwner)?.lifecycle
+
+    override suspend fun setSource(source: SourceDescription): SourceDescription {
+        val yospaceSource = source.sources.find { it.ssai is YospaceSsaiDescription } ?: return source
+        val ssaiDescription = yospaceSource.ssai as? YospaceSsaiDescription ?: return source
+
+        // Create the Yospace session
+        val src = yospaceSource.src
+        val sessionProperties = ssaiDescription.sessionProperties.copy(
+            userAgent = ssaiDescription.sessionProperties.userAgent.ifEmpty { USER_AGENT }
+        )
+        val session = when (ssaiDescription.streamType) {
+            YospaceStreamType.LIVE -> createSessionLive(src, sessionProperties)
+
+            YospaceStreamType.NONLINEAR,
+            YospaceStreamType.LIVEPAUSE -> createSessionDVRLive(src, sessionProperties)
+
+            YospaceStreamType.VOD -> createSessionVOD(src, sessionProperties)
+        }
+
+        when (session.sessionState) {
+            Session.SessionState.INITIALISED,
+            Session.SessionState.NO_ANALYTICS -> {
+                sourceWithYospace = source
+                // Set up
+                setupSession(session)
+                // Notify listener
+                listener.onSessionAvailable()
+                // Replace source with playback URL
+                val newSource = source.replaceSources(source.sources.toMutableList().apply {
+                    remove(yospaceSource)
+                    add(0, yospaceSource.replaceSrc(session.playbackUrl))
+                })
+                return newSource
+            }
+
+            Session.SessionState.FAILED -> {
+                val resultCode = session.resultCode
+                session.shutdown()
+                throw Exception(getSessionErrorMessage(resultCode))
+            }
+
+            Session.SessionState.SHUTDOWN -> {
+                // Already shutdown, ignore
+            }
+
+            else -> {
+                Log.d(TAG, "Unexpected Yospace session state: ${session.sessionState}")
+                session.shutdown()
+            }
+        }
+        return source
+    }
+
+    private fun setupSession(session: Session) {
+        val isLive = session.playbackMode == Session.PlaybackMode.LIVE
+        this.session = session
+        if (isLive) {
+            // Timed metadata is only used for live playback
+            // https://developer.yospace.com/sdk-documentation/android/userguide/latest/en/provide-necessary-information-to-the-sdk.html#video-playback-position
+            timedMetadataHandler = TimedMetadataHandler(player, onTimedMetadata)
+        }
+        adHandler = AdHandler(player, controller, uiHandler, this).also {
+            session.addAnalyticObserver(it)
+        }
+        session.addAnalyticObserver(analyticEventObserver)
+        addPlayerListeners(isLive)
+        updatePlayhead()
+    }
+
+    private fun destroySession() {
+        removePlayerListeners()
+        timedMetadataHandler?.apply {
+            destroy()
+            timedMetadataHandler = null
+        }
+        adHandler?.apply {
+            session?.removeAnalyticObserver(this)
+            destroy()
+            adHandler = null
+        }
+        session?.apply {
+            removeAnalyticObserver(analyticEventObserver)
+            shutdown()
+            session = null
+        }
+        streamStart = null
+    }
+
+    private fun addPlayerListeners(isLive: Boolean) {
+        addStreamStartListeners()
+        player.addEventListener(PlayerEventTypes.VOLUMECHANGE, onVolumeChange)
+        player.addEventListener(PlayerEventTypes.PLAY, onPlay)
+        player.addEventListener(PlayerEventTypes.ENDED, onEnded)
+        player.addEventListener(PlayerEventTypes.PAUSE, onPause)
+        player.addEventListener(PlayerEventTypes.SEEKED, onSeeked)
+        player.addEventListener(PlayerEventTypes.WAITING, onWaiting)
+        player.addEventListener(PlayerEventTypes.PLAYING, onPlaying)
+        if (!isLive) {
+            // Playhead position is only used for DVR live and VOD playback
+            // https://developer.yospace.com/sdk-documentation/android/userguide/latest/en/provide-necessary-information-to-the-sdk.html#video-playback-position
+            player.addEventListener(PlayerEventTypes.TIMEUPDATE, onTimeUpdate)
+        }
+    }
+
+    private fun removePlayerListeners() {
+        removeStreamStartListeners()
+        player.removeEventListener(PlayerEventTypes.VOLUMECHANGE, onVolumeChange)
+        player.removeEventListener(PlayerEventTypes.PLAY, onPlay)
+        player.removeEventListener(PlayerEventTypes.ENDED, onEnded)
+        player.removeEventListener(PlayerEventTypes.PAUSE, onPause)
+        player.removeEventListener(PlayerEventTypes.SEEKED, onSeeked)
+        player.removeEventListener(PlayerEventTypes.WAITING, onWaiting)
+        player.removeEventListener(PlayerEventTypes.PLAYING, onPlaying)
+        player.removeEventListener(PlayerEventTypes.TIMEUPDATE, onTimeUpdate)
+    }
+
+    private fun addStreamStartListeners() {
+        player.addEventListener(PlayerEventTypes.LOADEDMETADATA, onSeekableChange)
+        player.addEventListener(PlayerEventTypes.DURATIONCHANGE, onSeekableChange)
+        player.addEventListener(PlayerEventTypes.TIMEUPDATE, onSeekableChange)
+    }
+
+    private fun removeStreamStartListeners() {
+        player.addEventListener(PlayerEventTypes.LOADEDMETADATA, onSeekableChange)
+        player.addEventListener(PlayerEventTypes.DURATIONCHANGE, onSeekableChange)
+        player.addEventListener(PlayerEventTypes.TIMEUPDATE, onSeekableChange)
+    }
+
+    private val onVolumeChange = EventListener<VolumeChangeEvent> {
+        val muted = player.isMuted
+        if (isMuted != muted) {
+            isMuted = muted
+            session?.onVolumeChange(muted)
+        }
+    }
+
+    private val onPlay = EventListener<PlayEvent> {
+        if (!didFirstPlay) {
+            didFirstPlay = true
+            session?.onPlayerEvent(PlaybackEventHandler.PlayerEvent.START, currentPlayhead)
+        } else {
+            session?.onPlayerEvent(PlaybackEventHandler.PlayerEvent.RESUME, currentPlayhead)
+        }
+    }
+
+    private val onEnded = EventListener<EndedEvent> {
+        session?.onPlayerEvent(PlaybackEventHandler.PlayerEvent.STOP, currentPlayhead)
+    }
+
+    private val onPause = EventListener<PauseEvent> {
+        session?.onPlayerEvent(PlaybackEventHandler.PlayerEvent.PAUSE, currentPlayhead)
+    }
+
+    private val onSeeked = EventListener<SeekedEvent> {
+        session?.onPlayerEvent(PlaybackEventHandler.PlayerEvent.SEEK, currentPlayhead)
+    }
+
+    private val onWaiting = EventListener<WaitingEvent> {
+        isStalling = true
+        session?.onPlayerEvent(PlaybackEventHandler.PlayerEvent.STALL, currentPlayhead)
+    }
+
+    private val onPlaying = EventListener<PlayingEvent> {
+        if (isStalling) {
+            isStalling = false
+            session?.onPlayerEvent(PlaybackEventHandler.PlayerEvent.CONTINUE, currentPlayhead)
+        }
+    }
+
+    private val onSeekableChange = EventListener<Event<*>> {
+        updateStreamStart()
+    }
+
+    private val onTimeUpdate = EventListener<TimeUpdateEvent> {
+        updatePlayhead()
+    }
+
+    private val onTimedMetadata = TimedMetadataCallback { metadata, startTime ->
+        val playhead = toPlayhead(startTime)
+        session?.onTimedMetadata(TimedMetadata.createFromMetadata(metadata.ymid, metadata.yseq, metadata.ytyp, metadata.ydur, playhead))
+    }
+
+    override fun fromPlayhead(playhead: Long): Double {
+        val relativeTime = playhead.toDouble() / 1000.0
+        return relativeTime + (streamStart ?: 0.0)
+    }
+
+    override fun toPlayhead(playerTime: Double): Long {
+        val relativeTime = playerTime - (streamStart ?: 0.0)
+        return (relativeTime * 1000.0).toLong()
+    }
+
+    private fun updatePlayhead() {
+        val playhead = currentPlayhead
+        session?.onPlayheadUpdate(playhead)
+        adHandler?.onTimeUpdate(playhead)
+    }
+
+    private fun updateStreamStart() {
+        if (streamStart != null) return
+        val seekable = player.seekable
+        if (seekable.length() <= 0) return
+        val seekableStart = seekable.getStart(0)
+        val seekableEnd = seekable.getEnd(0)
+        if (seekableStart < seekableEnd || seekableEnd > 0.0) {
+            streamStart = seekableStart
+            removeStreamStartListeners()
+        }
+    }
+
+    override suspend fun resetSource() {
+        destroySession()
+        didFirstPlay = false
+        isStalling = false
+        sourceWithYospace = null
+    }
+
+    override fun onPause(owner: LifecycleOwner) {
+        sourceWithYospace?.let {
+            wasPlaying = !player.isPaused
+        }
+    }
+
+    override fun onStop(owner: LifecycleOwner) {
+        // Yospace session should be shutdown while the app is in the background
+        destroySession()
+    }
+
+    override fun onStart(owner: LifecycleOwner) {
+        // Restore source and start new Yospace session when app returns to foreground
+        sourceWithYospace?.let {
+            val player = this.player
+            player.source = it
+            if (wasPlaying) {
+                player.play()
+            }
+        }
+    }
+
+    init {
+        lifecycle?.addObserver(this)
+    }
+
+    override suspend fun destroy() {
+        resetSource()
+        lifecycle?.removeObserver(this)
+        uiHandler.destroy()
+    }
+}
+
+private suspend fun createSessionLive(url: String, properties: Session.SessionProperties?) = suspendCoroutine { continuation ->
+    SessionLive.create(url, properties) { event -> continuation.resume(event.payload) }
+}
+
+private suspend fun createSessionDVRLive(url: String, properties: Session.SessionProperties?) = suspendCoroutine { continuation ->
+    SessionDVRLive.create(url, properties) { event -> continuation.resume(event.payload) }
+}
+
+private suspend fun createSessionVOD(url: String, properties: Session.SessionProperties?) = suspendCoroutine { continuation ->
+    SessionVOD.create(url, properties) { event -> continuation.resume(event.payload) }
+}
+
+private fun getSessionErrorMessage(resultCode: Int): String {
+    val message = when (resultCode) {
+        YospaceSessionResultCode.MALFORMED_URL -> "The stream URL is not correctly formatted"
+        YospaceSessionResultCode.CONNECTION_ERROR -> "Connection error"
+        YospaceSessionResultCode.CONNECTION_TIMEOUT -> "Connection timeout"
+        else -> "Session could not be initialised"
+    }
+    return "Yospace: $message (code = $resultCode)"
+}
\ No newline at end of file
diff --git a/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/YospaceResultCode.kt b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/YospaceResultCode.kt
new file mode 100644
index 00000000..df9962b6
--- /dev/null
+++ b/connectors/yospace/src/main/java/com/theoplayer/android/connector/yospace/internal/YospaceResultCode.kt
@@ -0,0 +1,8 @@
+package com.theoplayer.android.connector.yospace.internal
+
+internal object YospaceSessionResultCode {
+    val CONNECTION_ERROR = -1
+    val CONNECTION_TIMEOUT = -2
+    val MALFORMED_URL = -3
+    val UNKNOWN_FORMAT = -20
+}
\ No newline at end of file
diff --git a/connectors/yospace/src/main/res/layout/default_ad_overlay.xml b/connectors/yospace/src/main/res/layout/default_ad_overlay.xml
new file mode 100644
index 00000000..1ad552d7
--- /dev/null
+++ b/connectors/yospace/src/main/res/layout/default_ad_overlay.xml
@@ -0,0 +1,26 @@
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:layout_gravity="center">
+
+    <Button
+        android:id="@+id/theo_yospace_linear_clickthrough"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_alignParentEnd="true"
+        android:layout_alignParentTop="true"
+        android:text="@string/txt_linear_clickthrough" />
+
+    <LinearLayout
+        android:id="@+id/theo_yospace_nonlinear"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_alignParentStart="true"
+        android:layout_alignParentTop="true"
+        android:layout_alignWithParentIfMissing="true"
+        android:layout_margin="8dp"
+        android:layout_toStartOf="@+id/theo_yospace_linear_clickthrough"
+        android:gravity="top"
+        android:orientation="vertical" />
+
+</RelativeLayout>
\ No newline at end of file
diff --git a/connectors/yospace/src/main/res/values/dimens.xml b/connectors/yospace/src/main/res/values/dimens.xml
new file mode 100644
index 00000000..79f5b886
--- /dev/null
+++ b/connectors/yospace/src/main/res/values/dimens.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <dimen name="nonlinear_height">72dp</dimen>
+</resources>
\ No newline at end of file
diff --git a/connectors/yospace/src/main/res/values/ids.xml b/connectors/yospace/src/main/res/values/ids.xml
new file mode 100644
index 00000000..1f3fb26c
--- /dev/null
+++ b/connectors/yospace/src/main/res/values/ids.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <item type="id" name="theo_ads_container" />
+    <item type="id" name="theo_yospace_container" />
+    <item type="id" name="theo_yospace_linear_clickthrough" />
+</resources>
\ No newline at end of file
diff --git a/connectors/yospace/src/main/res/values/strings.xml b/connectors/yospace/src/main/res/values/strings.xml
new file mode 100644
index 00000000..ebf2e433
--- /dev/null
+++ b/connectors/yospace/src/main/res/values/strings.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="txt_ad">Advertisement</string>
+    <string name="txt_linear_clickthrough">Visit Advertiser</string>
+</resources>
diff --git a/connectors/yospace/src/test/java/com/theoplayer/android/connector/yospace/internal/YospaceSsaiDescriptionTests.kt b/connectors/yospace/src/test/java/com/theoplayer/android/connector/yospace/internal/YospaceSsaiDescriptionTests.kt
new file mode 100644
index 00000000..f334d3e5
--- /dev/null
+++ b/connectors/yospace/src/test/java/com/theoplayer/android/connector/yospace/internal/YospaceSsaiDescriptionTests.kt
@@ -0,0 +1,76 @@
+package com.theoplayer.android.connector.yospace.internal
+
+import com.theoplayer.android.connector.yospace.YospaceConnector
+import com.theoplayer.android.connector.yospace.YospaceSsaiDescription
+import com.theoplayer.android.connector.yospace.YospaceSsaiDescriptionSerializer
+import com.theoplayer.android.connector.yospace.YospaceStreamType
+import com.yospace.admanagement.Session.SessionProperties
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.jsonObject
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+
+class YospaceSsaiDescriptionSerializerTests {
+    private lateinit var serializer: YospaceSsaiDescriptionSerializer
+
+    @Before
+    fun setup() {
+        serializer = YospaceSsaiDescriptionSerializer()
+    }
+
+    @Test
+    fun givenEmptySsaiDescription_WhenSerialize_ThenReturnsExpected() {
+        val ssaiDescription = YospaceSsaiDescription()
+        val jsonString = serializer.toJson(ssaiDescription)
+        val jsonObject = Json.parseToJsonElement(jsonString).jsonObject
+        assertEquals(jsonObject["integration"], JsonPrimitive(YospaceConnector.INTEGRATION_ID))
+        assertEquals(jsonObject["streamType"], JsonPrimitive(YospaceStreamType.LIVE.toString()))
+        val jsonSessionProperties = jsonObject["sessionProperties"]?.jsonObject
+        assertEquals(
+            jsonSessionProperties?.keys, setOf(
+                "requestTimeout",
+                "resourceTimeout",
+                "userAgent",
+                "proxyUserAgent",
+                "keepProxyAlive",
+                "prefetchResources",
+                "fireHistoricalBeacons",
+                "applyEncryptedTracking",
+                "excludedCategories",
+                "consecutiveBreakTolerance",
+                "token",
+                "customHttpHeaders"
+            )
+        )
+    }
+
+    @Test
+    fun givenSsaiDescriptionWithStreamType_WhenSerialize_ThenReturnsExpected() {
+        val ssaiDescription = YospaceSsaiDescription(
+            streamType = YospaceStreamType.LIVEPAUSE
+        )
+        val jsonString = serializer.toJson(ssaiDescription)
+        val jsonObject = Json.parseToJsonElement(jsonString).jsonObject
+        assertEquals(jsonObject["streamType"], JsonPrimitive(YospaceStreamType.LIVEPAUSE.toString()))
+    }
+
+    @Test
+    fun givenSsaiDescriptionWithSessionProperties_WhenSerialize_ThenReturnsExpected() {
+        val testUserAgent = "Test User Agent"
+        val testHeaders = mapOf("X-Hello" to "World")
+        val ssaiDescription = YospaceSsaiDescription(
+            sessionProperties = SessionProperties().apply {
+                userAgent = testUserAgent
+                customHttpHeaders = testHeaders
+            }
+        )
+        val jsonString = serializer.toJson(ssaiDescription)
+        val jsonObject = Json.parseToJsonElement(jsonString).jsonObject
+        val jsonSessionProperties = jsonObject["sessionProperties"]?.jsonObject
+        assertEquals(jsonSessionProperties?.get("userAgent"), JsonPrimitive(testUserAgent))
+        assertEquals(jsonSessionProperties?.get("customHttpHeaders"), JsonObject(testHeaders.mapValues { JsonPrimitive(it.value) }))
+    }
+}
diff --git a/connectors/yospace/src/test/java/com/theoplayer/android/connector/yospace/samples/YospaceConnectorSamples.kt b/connectors/yospace/src/test/java/com/theoplayer/android/connector/yospace/samples/YospaceConnectorSamples.kt
new file mode 100644
index 00000000..fbc9deef
--- /dev/null
+++ b/connectors/yospace/src/test/java/com/theoplayer/android/connector/yospace/samples/YospaceConnectorSamples.kt
@@ -0,0 +1,24 @@
+package com.theoplayer.android.connector.yospace.samples
+
+import android.app.Activity
+import com.theoplayer.android.api.THEOplayerView
+import com.theoplayer.android.api.source.SourceDescription
+import com.theoplayer.android.api.source.TypedSource
+import com.theoplayer.android.connector.yospace.YospaceConnector
+import com.theoplayer.android.connector.yospace.YospaceSsaiDescription
+import com.theoplayer.android.connector.yospace.YospaceStreamType
+
+fun createYospaceConnector(activity: Activity) {
+    // Set up the player and the connector
+    val theoplayerView = THEOplayerView(activity)
+    val yospaceConnector = YospaceConnector(theoplayerView)
+
+    // Play a stream with Yospace SSAI
+    theoplayerView.player.source = SourceDescription.Builder(
+        TypedSource.Builder("https://example.com/stream.m3u8")
+            .ssai(
+                YospaceSsaiDescription(streamType = YospaceStreamType.LIVE)
+            )
+            .build()
+    ).build()
+}
\ No newline at end of file
diff --git a/gradle.properties b/gradle.properties
index 6129ca74..ee33ca47 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -21,6 +21,8 @@ kotlin.code.style=official
 # resources declared in the library itself and none from the library's dependencies,
 # thereby reducing the size of the R class for that library
 android.nonTransitiveRClass=true
+android.defaults.buildfeatures.buildconfig=true
+android.nonFinalResIds=true
 groupId=com.theoplayer.android-connector
 sdkVersion=7.6.0
 
@@ -28,5 +30,4 @@ sdkVersion=7.6.0
 lifecycleVersion=2.5.1
 convivaVersion=4.0.35
 comscoreVersion=6.10.0
-android.defaults.buildfeatures.buildconfig=true
-android.nonFinalResIds=false
\ No newline at end of file
+yospaceVersion=3.6.7
diff --git a/settings.gradle b/settings.gradle
index 4432798d..e39afd8f 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -12,7 +12,14 @@ dependencyResolutionManagement {
         google()
         mavenCentral()
         maven { url 'https://maven.theoplayer.com/releases/' }
-        maven { url 'https://raw.githubusercontent.com/NielsenDigitalSDK/nielsenappsdk-android/master/'}
+        maven { url 'https://raw.githubusercontent.com/NielsenDigitalSDK/nielsenappsdk-android/master/' }
+        maven {
+            url 'https://yospacerepo.jfrog.io/yospacerepo/android-sdk'
+            credentials {
+                username System.getenv("YOSPACE_USERNAME")
+                password System.getenv("YOSPACE_PASSWORD")
+            }
+        }
     }
 }
 
@@ -22,3 +29,4 @@ include ':connectors:analytics:comscore'
 include ':connectors:analytics:conviva'
 include ':connectors:analytics:nielsen'
 include ':connectors:mediasession'
+include ':connectors:yospace'