spactureai-mobile-player 1.0.30

package/android/build.gradle

@@ -0,0 +1,249 @@
+buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["UnifiedPlayer_kotlinVersion"]
+  def minKotlin_version = project.properties["UnifiedPlayer_minKotlinVersion"]
+
+  def androidx_version = rootProject.ext.has('androidxActivityVersion') ? rootProject.ext.get('androidxActivityVersion') : project.properties['UnifiedPlayer_androidxActivityVersion']
+  def minAndroidx_version = project.properties["UnifiedPlayer_androidxActivityVersion"]
+
+  def isVersionAtLeast = { version, minVersion ->
+    def (major, minor, patch) = version.tokenize('.')
+    def (minMajor, minMinor, minPatch) = minVersion.tokenize('.')
+
+    // major version is greater
+    if (major.toInteger() > minMajor.toInteger()) return true
+
+    // major version is equal, minor version is greater
+    if (major.toInteger() == minMajor.toInteger() && minor.toInteger() > minMinor.toInteger()) return true
+
+    // major version is equal, minor version is equal, patch version is greater
+    if (major.toInteger() == minMajor.toInteger() && minor.toInteger() == minMinor.toInteger() && patch.toInteger() >= minPatch.toInteger()) return true
+
+    return false
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+
+  ext {
+    if (!isVersionAtLeast(kotlin_version, minKotlin_version)) {
+      throw new GradleException("Kotlin version must be at least $minKotlin_version (current: $kotlin_version)")
+    }
+
+    if (!isVersionAtLeast(androidx_version, minAndroidx_version)) {
+      throw new GradleException("AndroidX version must be at least $minAndroidx_version (current: $androidx_version)")
+    }
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply from: '../nitrogen/generated/android/UnifiedPlayer+autolinking.gradle'
+apply from: './fix-prefab.gradle'
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["UnifiedPlayer_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["UnifiedPlayer_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+def ExoplayerDependenciesList = [
+  "useExoplayerDash",
+  "useExoplayerHls",
+]
+
+def ExoplayerDependencies = ExoplayerDependenciesList.collectEntries { property ->
+  [(property): getExtOrDefault(property)?.toBoolean() ?: false]
+}
+
+// Print Configuration
+println "[UnifiedPlayer] Exoplayer Dependencies Configuration:"
+ExoplayerDependenciesList.each { propertyName ->
+  def propertyValue = ExoplayerDependencies[propertyName]
+  println "$propertyName: $propertyValue"
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.unifiedplayer"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    buildConfigField "boolean", "USE_EXOPLAYER_DASH", ExoplayerDependencies.useExoplayerDash.toString()
+    buildConfigField "boolean", "USE_EXOPLAYER_HLS", ExoplayerDependencies.useExoplayerHls.toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-O2 -frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so",
+            "**/libreactnative.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      if (!isNewArchitectureEnabled()) {
+        java.srcDirs += ["src/paper/java"]
+      }
+
+      if (!ExoplayerDependencies.useExoplayerDash) {
+        java.srcDirs += ["src/stubs/dash"]
+      }
+
+      if (!ExoplayerDependencies.useExoplayerHls) {
+        java.srcDirs += ["src/stubs/hls"]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+def media3_version = getExtOrDefault("media3Version")
+def androidxCore_version = getExtOrDefault("androidxCoreVersion")
+def androidxActivity_version = getExtOrDefault("androidxActivityVersion")
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  // Add a dependency on NitroModules
+  implementation project(":react-native-nitro-modules")
+
+  implementation "androidx.core:core-ktx:$androidxCore_version"
+  implementation "androidx.activity:activity-ktx:$androidxActivity_version"
+
+  // For media playback using ExoPlayer
+  implementation "androidx.media3:media3-exoplayer:$media3_version"
+
+  // Common functionality used across multiple media libraries
+  implementation "androidx.media3:media3-common:$media3_version"
+
+  // For building media playback UIs
+  implementation "androidx.media3:media3-ui:$media3_version"
+
+  // Common functionality for loading data
+  implementation "androidx.media3:media3-datasource:$media3_version"
+
+  // For loading data using the OkHttp network stack
+  implementation "androidx.media3:media3-datasource-okhttp:$media3_version"
+
+  // For Media Session
+  implementation "androidx.media3:media3-session:$media3_version"
+
+  if (ExoplayerDependencies.useExoplayerDash) {
+    implementation "androidx.media3:media3-exoplayer-dash:$media3_version"
+  }
+
+  if (ExoplayerDependencies.useExoplayerHls) {
+    implementation "androidx.media3:media3-exoplayer-hls:$media3_version"
+  }
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/spec/fabric")
+    libraryName = "RNCVideoView"
+    codegenJavaPackageName = "com.facebook.react.viewmanagers"
+  }
+}

package/android/fix-prefab.gradle

@@ -0,0 +1,51 @@
+tasks.configureEach { task ->
+  // Make sure that we generate our prefab publication file only after having built the native library
+  // so that not a header publication file, but a full configuration publication will be generated, which
+  // will include the .so file
+
+  def prefabConfigurePattern = ~/^prefab(.+)ConfigurePackage$/
+  def matcher = task.name =~ prefabConfigurePattern
+  if (matcher.matches()) {
+    def variantName = matcher[0][1]
+    task.outputs.upToDateWhen { false }
+    task.dependsOn("externalNativeBuild${variantName}")
+  }
+}
+
+afterEvaluate {
+  def abis = reactNativeArchitectures()
+  rootProject.allprojects.each { proj ->
+    if (proj === rootProject) return
+
+    def dependsOnThisLib = proj.configurations.findAll { it.canBeResolved }.any { config ->
+      config.dependencies.any { dep ->
+        dep.group == project.group && dep.name == project.name
+      }
+    }
+    if (!dependsOnThisLib && proj != project) return
+
+    if (!proj.plugins.hasPlugin('com.android.application') && !proj.plugins.hasPlugin('com.android.library')) {
+      return
+    }
+
+    def variants = proj.android.hasProperty('applicationVariants') ? proj.android.applicationVariants : proj.android.libraryVariants
+    // Touch the prefab_config.json files to ensure that in ExternalNativeJsonGenerator.kt we will re-trigger the prefab CLI to
+    // generate a libnameConfig.cmake file that will contain our native library (.so).
+    // See this condition: https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:build-system/gradle-core/src/main/java/com/android/build/gradle/tasks/ExternalNativeJsonGenerator.kt;l=207-219?q=createPrefabBuildSystemGlue
+    variants.all { variant ->
+      def variantName = variant.name
+      abis.each { abi ->
+        def searchDir = new File(proj.projectDir, ".cxx/${variantName}")
+        if (!searchDir.exists()) return
+        def matches = []
+        searchDir.eachDir { randomDir ->
+          def prefabFile = new File(randomDir, "${abi}/prefab_config.json")
+          if (prefabFile.exists()) matches << prefabFile
+        }
+        matches.each { prefabConfig ->
+          prefabConfig.setLastModified(System.currentTimeMillis())
+        }
+      }
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,15 @@
+UnifiedPlayer_kotlinVersion=1.9.24
+UnifiedPlayer_minKotlinVersion=1.8.0
+UnifiedPlayer_minSdkVersion=24
+UnifiedPlayer_targetSdkVersion=35
+UnifiedPlayer_compileSdkVersion=35
+UnifiedPlayer_ndkVersion=27.1.12297006
+
+UnifiedPlayer_useExoplayerDash=true
+UnifiedPlayer_useExoplayerHls=true
+
+UnifiedPlayer_media3Version=1.4.1
+UnifiedPlayer_androidxCoreVersion=1.13.1
+UnifiedPlayer_androidxActivityVersion=1.9.3
+
+android.useAndroidX=true

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,10 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.unifiedplayer">
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="32" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" android:maxSdkVersion="32" />
+    <uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
+    <application android:hardwareAccelerated="true">
+    </application>
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,9 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <uses-permission android:name="android.permission.INTERNET" />
+  <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="32" />
+  <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" android:maxSdkVersion="32" />
+  <uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
+  <application android:hardwareAccelerated="true">
+  </application>
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,9 @@
+#include <fbjni/fbjni.h>
+#include <jni.h>
+#include "UnifiedPlayerOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return facebook::jni::initialize(vm, []() {
+    margelo::nitro::unifiedplayer::registerAllNatives();
+  });
+}

package/android/src/main/java/com/unifiedplayer/core/AudioFocusManager.kt

@@ -0,0 +1,233 @@
+package com.unifiedplayer.core
+
+import android.content.Context
+import android.media.AudioAttributes
+import android.media.AudioManager
+import android.media.AudioFocusRequest
+import android.os.Build
+import androidx.annotation.OptIn
+import androidx.annotation.RequiresApi
+import androidx.media3.common.util.UnstableApi
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.unifiedplayer.HybridVideoPlayer
+import com.margelo.nitro.unifiedplayer.MixAudioMode
+import kotlin.getValue
+import com.unifiedplayer.core.utils.Threading
+
+@OptIn(UnstableApi::class)
+class AudioFocusManager() {
+  private val players = mutableListOf<HybridVideoPlayer>()
+  private var currentMixAudioMode: MixAudioMode? = null
+  private var audioFocusRequest: AudioFocusRequest? = null
+
+  val appContext by lazy {
+    NitroModules.applicationContext ?: throw UnknownError()
+  }
+
+  private val audioManager by lazy {
+    appContext.getSystemService(Context.AUDIO_SERVICE) as? AudioManager ?: throw UnknownError()
+  }
+
+  private val audioFocusChangeListener = AudioManager.OnAudioFocusChangeListener { focusChange ->
+    when (focusChange) {
+      AudioManager.AUDIOFOCUS_GAIN -> {
+        unDuckActivePlayers()
+      }
+      AudioManager.AUDIOFOCUS_LOSS -> {
+        pauseActivePlayers()
+        currentMixAudioMode = null
+        audioFocusRequest = null
+      }
+      AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+        val mixAudioMode = determineRequiredMixMode()
+        if (mixAudioMode != MixAudioMode.MIXWITHOTHERS) {
+          pauseActivePlayers()
+          currentMixAudioMode = null
+          audioFocusRequest = null
+        }
+      }
+      AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+        val mixAudioMode = determineRequiredMixMode()
+        when (mixAudioMode) {
+          MixAudioMode.DONOTMIX -> pauseActivePlayers()
+          else -> duckActivePlayers()
+        }
+      }
+    }
+  }
+
+  fun registerPlayer(player: HybridVideoPlayer) {
+    if (!players.contains(player)) {
+      players.add(player)
+    }
+  }
+
+  fun unregisterPlayer(player: HybridVideoPlayer) {
+    players.remove(player)
+    if (players.isEmpty()) {
+      abandonAudioFocus()
+    } else {
+      requestAudioFocusUpdate()
+    }
+  }
+
+  fun requestAudioFocusUpdate() {
+    Threading.runOnMainThread {
+      val requiredMixMode = determineRequiredMixMode()
+
+      if (requiredMixMode == null) {
+        abandonAudioFocus()
+        return@runOnMainThread
+      }
+
+      if (currentMixAudioMode != requiredMixMode) {
+        requestAudioFocus(requiredMixMode)
+      }
+    }
+  }
+
+  private fun determineRequiredMixMode(): MixAudioMode? {
+    val activePlayers = players.filter { player ->
+      player.player.isPlaying && player.player.volume != 0f
+    }
+
+    if (activePlayers.isEmpty()) {
+      return null
+    }
+
+    val anyPlayerNeedsMixWithOthers = activePlayers.any { player ->
+      player.mixAudioMode == MixAudioMode.MIXWITHOTHERS
+    }
+
+    if (anyPlayerNeedsMixWithOthers) {
+      abandonAudioFocus()
+      return MixAudioMode.MIXWITHOTHERS
+    }
+
+    val anyPlayerNeedsExclusiveFocus = activePlayers.any { player ->
+      player.mixAudioMode == MixAudioMode.DONOTMIX
+    }
+
+    val anyPlayerNeedsDucking = activePlayers.any { player ->
+      player.mixAudioMode == MixAudioMode.DUCKOTHERS
+    }
+
+    return when {
+      anyPlayerNeedsExclusiveFocus -> MixAudioMode.DONOTMIX
+      anyPlayerNeedsDucking -> MixAudioMode.DUCKOTHERS
+      else -> MixAudioMode.AUTO
+    }
+  }
+
+    private fun requestAudioFocus(mixMode: MixAudioMode) {
+    val focusType = when (mixMode) {
+      MixAudioMode.DONOTMIX -> AudioManager.AUDIOFOCUS_GAIN
+      MixAudioMode.DUCKOTHERS -> AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK
+      MixAudioMode.AUTO -> AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK
+      MixAudioMode.MIXWITHOTHERS -> return // No focus needed for mix with others
+    }
+
+    val result = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      requestAudioFocusNew(focusType)
+    } else {
+      requestAudioFocusLegacy(focusType)
+    }
+
+    if (result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
+      currentMixAudioMode = mixMode
+    } else {
+      currentMixAudioMode = null
+      // Pause players since audio focus couldn't be obtained
+      pauseActivePlayers()
+    }
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun requestAudioFocusNew(focusType: Int): Int {
+
+    audioFocusRequest = AudioFocusRequest.Builder(focusType)
+      .setAudioAttributes(
+        AudioAttributes.Builder().run {
+          setUsage(AudioAttributes.USAGE_MEDIA)
+          setContentType(AudioAttributes.CONTENT_TYPE_MOVIE)
+          build()
+        }
+      )
+      .setOnAudioFocusChangeListener(audioFocusChangeListener)
+      .build()
+
+    return audioManager.requestAudioFocus(audioFocusRequest!!)
+  }
+
+  @Suppress("DEPRECATION")
+  private fun requestAudioFocusLegacy(focusType: Int): Int {
+    return audioManager.requestAudioFocus(
+      audioFocusChangeListener,
+      AudioManager.STREAM_MUSIC,
+      focusType
+    )
+  }
+
+  private fun abandonAudioFocus() {
+    if (currentMixAudioMode != null) {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        abandonAudioFocusNew()
+      } else {
+        abandonAudioFocusLegacy()
+      }
+      currentMixAudioMode = null
+      audioFocusRequest = null
+    }
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun abandonAudioFocusNew() {
+    audioFocusRequest?.let { request ->
+      audioManager.abandonAudioFocusRequest(request)
+    }
+  }
+
+  @Suppress("DEPRECATION")
+  private fun abandonAudioFocusLegacy() {
+    audioManager.abandonAudioFocus(audioFocusChangeListener)
+  }
+
+  private fun pauseActivePlayers() {
+    Threading.runOnMainThread {
+      players.forEach { player ->
+        player.player.let { mediaPlayer ->
+          if (mediaPlayer.volume != 0f && mediaPlayer.isPlaying) {
+            mediaPlayer.pause()
+          }
+        }
+      }
+    }
+  }
+
+  private fun duckActivePlayers() {
+    Threading.runOnMainThread {
+      players.forEach { player ->
+        player.player.let { mediaPlayer ->
+          // We need to duck the volume to 50%. After the audio focus is regained,
+          // we will restore the volume to the user's volume.
+          mediaPlayer.volume = mediaPlayer.volume * 0.5f
+        }
+      }
+    }
+  }
+
+  private fun unDuckActivePlayers() {
+    Threading.runOnMainThread {
+      // Resume players that were paused due to audio focus loss
+      players.forEach { player ->
+        player.player.let { mediaPlayer ->
+          // Restore full volume if it was ducked
+          if (mediaPlayer.volume != 0f && mediaPlayer.volume.toDouble() != player.userVolume) {
+            mediaPlayer.volume = player.userVolume.toFloat()
+          }
+        }
+      }
+    }
+  }
+}
+

package/android/src/main/java/com/unifiedplayer/core/VideoError.kt

@@ -0,0 +1,105 @@
+package com.unifiedplayer.core
+
+// Base class for all video errors
+abstract class VideoError(
+    open val code: String,
+    message: String
+) : Error("{%@$code::$message@%}")
+
+// Library related errors
+sealed class LibraryError(code: String, message: String) : VideoError(code, message) {
+  object Deallocated : LibraryError(
+    "library/deallocated",
+    "Object has been deallocated"
+  )
+
+  object ApplicationContextNotFound : LibraryError(
+    "library/application-context-not-found",
+    "Application context not found"
+  )
+
+  class MethodNotSupported(val methodName: String) : LibraryError(
+    "library/method-not-supported",
+    "Method $methodName() is not supported on Android"
+  )
+
+  object DRMPluginNotFound : LibraryError(
+    "library/drm-plugin-not-found",
+    "No DRM plugin have been found, please add one to the project",
+  )
+}
+
+// Player related errors
+sealed class PlayerError(code: String, message: String) : VideoError(code, message) {
+  object NotInitialized : PlayerError(
+    "player/not-initialized",
+    "Player has not been initialized (Or has been set to null)"
+  )
+
+  object AssetNotInitialized : PlayerError(
+    "player/asset-not-initialized",
+    "Asset has not been initialized (Or has been set to null)"
+  )
+
+  object InvalidSource : PlayerError(
+    "player/invalid-source",
+    "Invalid source passed to player"
+  )
+
+  object Cancelled : PlayerError(
+    "player/cancelled",
+    "Operation was cancelled"
+  )
+}
+
+// Source related errors
+sealed class SourceError(code: String, message: String) : VideoError(code, message) {
+  class InvalidUri(val uri: String) : SourceError(
+    "source/invalid-uri",
+    "Invalid source file uri: $uri"
+  )
+
+  class MissingReadFilePermission(val uri: String) : SourceError(
+    "source/missing-read-file-permission",
+    "Missing read file permission for source file at $uri"
+  )
+
+  class FileDoesNotExist(val uri: String) : SourceError(
+    "source/file-does-not-exist",
+    "File does not exist at URI: $uri"
+  )
+
+  object FailedToInitializeAsset : SourceError(
+    "source/failed-to-initialize-asset",
+    "Failed to initialize asset"
+  )
+
+  class UnsupportedContentType(val uri: String) : SourceError(
+    "source/unsupported-content-type",
+    "type of content (${uri}) is not supported"
+  )
+
+  object Cancelled : SourceError(
+    "source/cancelled",
+    "Operation was cancelled"
+  )
+}
+
+// View related errors
+sealed class VideoViewError(code: String, message: String) : VideoError(code, message) {
+  class ViewNotFound(val viewId: Int) : VideoViewError(
+    "view/not-found",
+    "View with viewId $viewId not found"
+  )
+  object ViewIsDeallocated : VideoViewError(
+    "view/deallocated",
+    "Attempt to access a view, but it has been deallocated (or not initialized)"
+  )
+  object PictureInPictureNotSupported : VideoViewError(
+    "view/picture-in-picture-not-supported",
+    "Picture in picture is not supported on this device"
+  )
+}
+
+// Unknown error
+class UnknownError : VideoError("unknown/unknown", "Unknown error")