bitmovin-player-react-native 0.14.2 → 0.15.0

package/README.md

@@ -12,7 +12,7 @@ This is an open-source project created to enable customers to integrate the Bitm
 
 ## Platform Support
 
-This library requires at least React Native 0.64+ and React 17+ to work properly. The **officially supported** platforms are:
+This library requires at least React Native 0.65+ and React 17+ to work properly. The **officially supported** platforms are:
 
 - **iOS/iPadOS/tvOS:** 14.0+
 - **Android:** 5.0+

package/RNBitmovinPlayer.podspec

@@ -19,7 +19,7 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
   s.dependency "React-Core"
-  s.dependency "BitmovinPlayer", "3.49.0"
+  s.dependency "BitmovinPlayer", "3.51.0"
   s.ios.dependency "GoogleAds-IMA-iOS-SDK", "3.18.4"
   s.tvos.dependency "GoogleAds-IMA-tvOS-SDK", "4.8.2"
 end

package/android/build.gradle

@@ -1,9 +1,9 @@
 buildscript {
-    ext {
-        kotlinVersion = '1.7.21'
-        androidToolsVersion = '7.4.2'
-        ktlintVersion = '11.6.0'
-    }
+    // 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["BitmovinPlayerReactNative_kotlinVersion"]
+    def ktlint_version = rootProject.ext.has("ktlintVersion") ? rootProject.ext.get("ktlintVersion") : project.properties["BitmovinPlayerReactNative_ktlintVersion"]
+    def android_tools_version = rootProject.ext.has("androidToolsVersion") ? rootProject.ext.get("androidToolsVersion") : project.properties["BitmovinPlayerReactNative_androidToolsVersion"]
+
     repositories {
         google()
         mavenCentral()
@@ -12,54 +12,96 @@ buildscript {
         }
     }
     dependencies {
-        classpath "com.android.tools.build:gradle:$androidToolsVersion"
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
-        classpath "org.jlleitschuh.gradle:ktlint-gradle:$ktlintVersion"
+        classpath "com.android.tools.build:gradle:$android_tools_version"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+        classpath "org.jlleitschuh.gradle:ktlint-gradle:$ktlint_version"
     }
 }
 
+def isNewArchitectureEnabled() {
+    return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 apply plugin: 'org.jlleitschuh.gradle.ktlint'
 
-repositories {
-    mavenLocal()
-    maven {
-        // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
-        url "$rootDir/../node_modules/react-native/android"
-    }
-    google()
-    mavenCentral()
-    maven { url 'https://artifacts.bitmovin.com/artifactory/public-releases' }
+if (isNewArchitectureEnabled()) {
+    apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["BitmovinPlayerReactNative_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["BitmovinPlayerReactNative_" + 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
 }
 
 android {
-    compileSdk 33
+    if (supportsNamespace()) {
+        namespace "com.bitmovin.player.reactnative"
+
+        sourceSets {
+            main {
+                manifest.srcFile "src/main/AndroidManifestNew.xml"
+            }
+        }
+    }
+
+    compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
     defaultConfig {
-        minSdkVersion 21
-        targetSdkVersion 33
-        versionCode 1
-        versionName '1.0'
+        minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+        targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
     }
+
     buildTypes {
         release {
             minifyEnabled false
         }
     }
+
     lintOptions {
-        disable 'GradleCompatible'
+        disable "GradleCompatible"
     }
+
     compileOptions {
         sourceCompatibility JavaVersion.VERSION_1_8
         targetCompatibility JavaVersion.VERSION_1_8
     }
+
+    buildFeatures {
+        buildConfig true
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
 }
 
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
 dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlinVersion"
-    implementation 'com.google.ads.interactivemedia.v3:interactivemedia:3.31.0'
-    implementation 'com.google.android.gms:play-services-ads-identifier:18.0.1'
-    implementation 'com.bitmovin.player:player:3.51.0+jason'
+    // 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:+' // From node_modules
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+    // Bitmovin
+    implementation 'com.google.ads.interactivemedia.v3:interactivemedia:3.31.0'
+    implementation 'com.google.android.gms:play-services-ads-identifier:18.0.1'
+    implementation 'com.bitmovin.player:player:3.54.0+jason'
 }

package/android/gradle.properties

@@ -1 +1,8 @@
 android.useAndroidX=true
+BitmovinPlayerReactNative_kotlinVersion=1.8.20
+BitmovinPlayerReactNative_minSdkVersion=21
+BitmovinPlayerReactNative_targetSdkVersion=33
+BitmovinPlayerReactNative_compileSdkVersion=33
+BitmovinPlayerReactNative_ndkversion=21.4.7075529
+BitmovinPlayerReactNative_androidToolsVersion=7.4.2
+BitmovinPlayerReactNative_ktlintVersion=11.6.0

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/bitmovin/player/reactnative/BitmovinBaseModule.kt

@@ -0,0 +1,106 @@
+package com.bitmovin.player.reactnative
+
+import android.util.Log
+import com.bitmovin.player.api.Player
+import com.bitmovin.player.api.source.Source
+import com.bitmovin.player.reactnative.extensions.drmModule
+import com.bitmovin.player.reactnative.extensions.offlineModule
+import com.bitmovin.player.reactnative.extensions.playerModule
+import com.bitmovin.player.reactnative.extensions.sourceModule
+import com.bitmovin.player.reactnative.extensions.uiManagerModule
+import com.facebook.react.bridge.*
+import com.facebook.react.uimanager.UIManagerModule
+
+private const val MODULE_NAME = "BitmovinBaseModule"
+
+/**
+ * Base for Bitmovin React modules.
+ *
+ * Provides many helper methods that are promise exception safe.
+ *
+ * In general, code should not throw while resolving a [Promise]. Instead, [Promise.reject] should be used.
+ * This doesn't match Kotlin's error style, which uses exception. The helper methods in this class, provide such
+ * convenience, they can only be called in a context that will catch any Exception and reject the [Promise].
+ *
+ */
+abstract class BitmovinBaseModule(
+    protected val context: ReactApplicationContext,
+) : ReactContextBaseJavaModule(context) {
+    /**
+     * Runs [block] on the UI thread with [UIManagerModule.addUIBlock] and [TPromise.resolve] [this] with
+     * its return value. If [block] throws, [Promise.reject] [this] with the [Throwable].
+     */
+    protected inline fun <T, R : T> TPromise<T>.resolveOnUiThread(
+        crossinline block: RejectPromiseOnExceptionBlock.() -> R,
+    ) {
+        val uiManager = runAndRejectOnException { uiManager } ?: return
+        uiManager.addUIBlock {
+            resolveOnCurrentThread { block() }
+        }
+    }
+
+    protected val RejectPromiseOnExceptionBlock.playerModule: PlayerModule get() = context.playerModule
+        ?: throw IllegalArgumentException("PlayerModule not found")
+
+    protected val RejectPromiseOnExceptionBlock.uiManager: UIManagerModule get() = context.uiManagerModule
+        ?: throw IllegalStateException("UIManager not found")
+
+    protected val RejectPromiseOnExceptionBlock.sourceModule: SourceModule get() = context.sourceModule
+        ?: throw IllegalStateException("SourceModule not found")
+
+    protected val RejectPromiseOnExceptionBlock.offlineModule: OfflineModule get() = context.offlineModule
+        ?: throw IllegalStateException("OfflineModule not found")
+
+    protected val RejectPromiseOnExceptionBlock.drmModule: DrmModule get() = context.drmModule
+        ?: throw IllegalStateException("DrmModule not found")
+
+    fun RejectPromiseOnExceptionBlock.getPlayer(
+        nativeId: NativeId,
+        playerModule: PlayerModule = this.playerModule,
+    ): Player = playerModule.getPlayerOrNull(nativeId) ?: throw IllegalArgumentException("Invalid PlayerId $nativeId")
+
+    fun RejectPromiseOnExceptionBlock.getSource(
+        nativeId: NativeId,
+        sourceModule: SourceModule = this.sourceModule,
+    ): Source = sourceModule.getSourceOrNull(nativeId) ?: throw IllegalArgumentException("Invalid SourceId $nativeId")
+}
+
+/** Run [block], returning it's return value. If [block] throws, [Promise.reject] [this] and return null. */
+inline fun <T, R> TPromise<T>.runAndRejectOnException(block: RejectPromiseOnExceptionBlock.() -> R): R? = try {
+    RejectPromiseOnExceptionBlock.block()
+} catch (e: Exception) {
+    reject(e)
+    null
+}
+
+/**
+ * [TPromise.resolve] [this] with [block] return value.
+ * If [block] throws, [Promise.reject] [this] with the [Throwable].
+ */
+inline fun <T> TPromise<T>.resolveOnCurrentThread(
+    crossinline block: RejectPromiseOnExceptionBlock.() -> T,
+): Unit = runAndRejectOnException { this@resolveOnCurrentThread.resolve(block()) } ?: Unit
+
+/** Receiver of code that can safely throw when resolving a [Promise]. */
+object RejectPromiseOnExceptionBlock
+
+/** Compile time wrapper for Promises to type check the resolved type [T]. */
+@JvmInline
+value class TPromise<T>(val promise: Promise) {
+    // Promise only support built-in types. Functions that return [Unit] must resolve to `null`.
+    fun resolve(value: T): Unit = promise.resolve(value.takeUnless { it is Unit })
+    fun reject(throwable: Throwable) {
+        Log.e(MODULE_NAME, "Failed to execute Bitmovin method", throwable)
+        promise.reject(throwable)
+    }
+}
+
+inline val Promise.int get() = TPromise<Int>(this)
+inline val Promise.unit get() = TPromise<Unit>(this)
+inline val Promise.string get() = TPromise<String>(this)
+inline val Promise.double get() = TPromise<Double>(this)
+inline val Promise.float get() = TPromise<Float>(this)
+inline val Promise.bool get() = TPromise<Boolean>(this)
+inline val Promise.map get() = TPromise<ReadableMap>(this)
+inline val Promise.array get() = TPromise<ReadableArray>(this)
+inline val <T> TPromise<T>.nullable get() = TPromise<T?>(promise)

package/android/src/main/java/com/bitmovin/player/reactnative/BitmovinCastManagerModule.kt

@@ -1,70 +1,54 @@
 package com.bitmovin.player.reactnative
 
 import com.bitmovin.player.casting.BitmovinCastManager
-import com.bitmovin.player.reactnative.converter.JsonConverter
+import com.bitmovin.player.reactnative.converter.toCastOptions
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.module.annotations.ReactModule
-import com.facebook.react.uimanager.UIManagerModule
 
 private const val MODULE_NAME = "BitmovinCastManagerModule"
 
 @ReactModule(name = MODULE_NAME)
-class BitmovinCastManagerModule(
-    private val context: ReactApplicationContext,
-) : ReactContextBaseJavaModule(context) {
+class BitmovinCastManagerModule(context: ReactApplicationContext) : BitmovinBaseModule(context) {
     override fun getName() = MODULE_NAME
 
     /**
      * Returns whether the [BitmovinCastManager] is initialized.
      */
     @ReactMethod
-    fun isInitialized(promise: Promise) = uiManager?.addUIBlock {
-        promise.resolve(BitmovinCastManager.isInitialized())
+    fun isInitialized(promise: Promise) = promise.unit.resolveOnUiThread {
+        BitmovinCastManager.isInitialized()
     }
 
     /**
      * Initializes the [BitmovinCastManager] with the given options.
      */
     @ReactMethod
-    fun initializeCastManager(options: ReadableMap?, promise: Promise) {
-        val castOptions = JsonConverter.toCastOptions(options)
-        uiManager?.addUIBlock {
-            BitmovinCastManager.initialize(
-                castOptions?.applicationId,
-                castOptions?.messageNamespace,
-            )
-            promise.resolve(null)
-        }
+    fun initializeCastManager(options: ReadableMap?, promise: Promise) = promise.unit.resolveOnUiThread {
+        val castOptions = options?.toCastOptions()
+        BitmovinCastManager.initialize(
+            castOptions?.applicationId,
+            castOptions?.messageNamespace,
+        )
     }
 
     /**
      * Sends a message to the receiver.
      */
     @ReactMethod
-    fun sendMessage(message: String, messageNamespace: String?, promise: Promise) {
-        uiManager?.addUIBlock {
-            BitmovinCastManager.getInstance().sendMessage(message, messageNamespace)
-            promise.resolve(null)
-        }
+    fun sendMessage(message: String, messageNamespace: String?, promise: Promise) = promise.unit.resolveOnUiThread {
+        BitmovinCastManager.getInstance().sendMessage(message, messageNamespace)
     }
 
     /**
      * Updates the context of the [BitmovinCastManager] to the current activity.
      */
     @ReactMethod
-    fun updateContext(promise: Promise) {
-        uiManager?.addUIBlock {
-            BitmovinCastManager.getInstance().updateContext(currentActivity)
-            promise.resolve(null)
-        }
+    fun updateContext(promise: Promise) = promise.unit.resolveOnUiThread {
+        BitmovinCastManager.getInstance().updateContext(currentActivity)
     }
-
-    private val uiManager: UIManagerModule?
-        get() = context.getNativeModule(UIManagerModule::class.java)
 }
 
 /**

package/android/src/main/java/com/bitmovin/player/reactnative/BufferModule.kt

@@ -2,66 +2,50 @@ package com.bitmovin.player.reactnative
 
 import com.bitmovin.player.api.buffer.BufferLevel
 import com.bitmovin.player.api.media.MediaType
-import com.bitmovin.player.reactnative.converter.JsonConverter
+import com.bitmovin.player.reactnative.converter.toBufferType
+import com.bitmovin.player.reactnative.converter.toJson
 import com.facebook.react.bridge.*
 import com.facebook.react.module.annotations.ReactModule
-import com.facebook.react.uimanager.UIManagerModule
 
 private const val MODULE_NAME = "BufferModule"
+private const val INVALID_BUFFER_TYPE = "Invalid buffer type"
 
 @ReactModule(name = MODULE_NAME)
-class BufferModule(private val context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
+class BufferModule(context: ReactApplicationContext) : BitmovinBaseModule(context) {
     override fun getName() = MODULE_NAME
 
     /**
      * Gets the [BufferLevel] from the Player
      * @param nativeId Target player id.
-     * @param type The [type of buffer][JsonConverter.toBufferType] to return the level for.
+     * @param type The [type of buffer][toBufferType] to return the level for.
      * @param promise JS promise object.
      */
     @ReactMethod
     fun getLevel(nativeId: NativeId, type: String, promise: Promise) {
-        uiManager()?.addUIBlock { _ ->
-            val player = playerModule()?.getPlayer(nativeId) ?: return@addUIBlock
-            val bufferType = JsonConverter.toBufferType(type)
-            if (bufferType == null) {
-                promise.reject("Error: ", "Invalid buffer type")
-                return@addUIBlock
-            }
-            val bufferLevels = RNBufferLevels(
-                player.buffer.getLevel(bufferType, MediaType.Audio),
-                player.buffer.getLevel(bufferType, MediaType.Video),
-            )
-            JsonConverter.fromRNBufferLevels(bufferLevels).let {
-                promise.resolve(it)
-            }
+        promise.map.resolveOnUiThread {
+            val player = getPlayer(nativeId)
+            val bufferType = type.toBufferTypeOrThrow()
+            RNBufferLevels(
+                audio = player.buffer.getLevel(bufferType, MediaType.Audio),
+                video = player.buffer.getLevel(bufferType, MediaType.Video),
+            ).toJson()
         }
     }
 
     /**
      * Sets the target buffer level for the chosen buffer type across all media types.
      * @param nativeId Target player id.
-     * @param type The [type of buffer][JsonConverter.toBufferType] to set the target level for.
+     * @param type The [type of buffer][toBufferType] to set the target level for.
      * @param value The value to set.
      */
     @ReactMethod
-    fun setTargetLevel(nativeId: NativeId, type: String, value: Double) {
-        uiManager()?.addUIBlock { _ ->
-            val player = playerModule()?.getPlayer(nativeId) ?: return@addUIBlock
-            val bufferType = JsonConverter.toBufferType(type) ?: return@addUIBlock
-            player.buffer.setTargetLevel(bufferType, value)
+    fun setTargetLevel(nativeId: NativeId, type: String, value: Double, promise: Promise) {
+        promise.unit.resolveOnUiThread {
+            getPlayer(nativeId).buffer.setTargetLevel(type.toBufferTypeOrThrow(), value)
         }
     }
 
-    /**
-     * Helper function that gets the instantiated `UIManagerModule` from modules registry.
-     */
-    private fun uiManager(): UIManagerModule? = context.getNativeModule(UIManagerModule::class.java)
-
-    /**
-     * Helper function that gets the instantiated `PlayerModule` from modules registry.
-     */
-    private fun playerModule(): PlayerModule? = context.getNativeModule(PlayerModule::class.java)
+    private fun String.toBufferTypeOrThrow() = toBufferType() ?: throw IllegalArgumentException(INVALID_BUFFER_TYPE)
 }
 
 /**

package/android/src/main/java/com/bitmovin/player/reactnative/DrmModule.kt

@@ -4,10 +4,10 @@ import android.util.Base64
 import com.bitmovin.player.api.drm.PrepareLicenseCallback
 import com.bitmovin.player.api.drm.PrepareMessageCallback
 import com.bitmovin.player.api.drm.WidevineConfig
-import com.bitmovin.player.reactnative.converter.JsonConverter
+import com.bitmovin.player.reactnative.converter.toWidevineConfig
 import com.facebook.react.bridge.*
 import com.facebook.react.module.annotations.ReactModule
-import com.facebook.react.uimanager.UIManagerModule
+import java.security.InvalidParameterException
 import java.util.concurrent.locks.Condition
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock
@@ -20,7 +20,7 @@ typealias PrepareCallback = (ByteArray) -> ByteArray
 private const val MODULE_NAME = "DrmModule"
 
 @ReactModule(name = MODULE_NAME)
-class DrmModule(private val context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
+class DrmModule(context: ReactApplicationContext) : BitmovinBaseModule(context) {
     /**
      * In-memory mapping from `nativeId`s to `WidevineConfig` instances.
      */
@@ -74,15 +74,15 @@ class DrmModule(private val context: ReactApplicationContext) : ReactContextBase
      * @param config `DrmConfig` object received from JS.
      */
     @ReactMethod
-    fun initWithConfig(nativeId: NativeId, config: ReadableMap?) {
-        uiManager()?.addUIBlock {
-            if (!drmConfigs.containsKey(nativeId) && config != null) {
-                JsonConverter.toWidevineConfig(config)?.let {
-                    drmConfigs[nativeId] = it
-                    initPrepareMessage(nativeId, config)
-                    initPrepareLicense(nativeId, config)
-                }
+    fun initWithConfig(nativeId: NativeId, config: ReadableMap, promise: Promise) {
+        promise.unit.resolveOnUiThread {
+            if (drmConfigs.containsKey(nativeId)) {
+                throw InvalidParameterException("NativeId already exists $nativeId")
             }
+            val widevineConfig = config.toWidevineConfig() ?: throw InvalidParameterException("Invalid widevine config")
+            widevineConfig.prepareMessageCallback = buildPrepareMessageCallback(nativeId, config)
+            widevineConfig.prepareLicenseCallback = buildPrepareLicense(nativeId, config)
+            drmConfigs[nativeId] = widevineConfig
         }
     }
 
@@ -118,24 +118,21 @@ class DrmModule(private val context: ReactApplicationContext) : ReactContextBase
     }
 
     /**
-     * Initialize the `prepareMessage` block in the `WidevineConfig` associated with `nativeId`.
-     * @param nativeId Instance ID.
+     * Initialize the `prepareMessage` block in the [widevineConfig]
+     * @param widevineConfig Instance ID.
      * @param config `DrmConfig` config object sent from JS.
      */
-    private fun initPrepareMessage(nativeId: NativeId, config: ReadableMap) {
-        val widevineConfig = drmConfigs[nativeId]
-        val widevineJson = config.getMap("widevine")
-        if (widevineConfig != null && widevineJson != null && widevineJson.hasKey("prepareMessage")) {
-            val prepareMessage = createPrepareCallback(
-                nativeId,
-                "onPrepareMessage",
-                preparedMessages,
-                preparedMessagesCondition,
-            )
-            widevineConfig.prepareMessageCallback = PrepareMessageCallback {
-                prepareMessage(it)
-            }
+    private fun buildPrepareMessageCallback(nativeId: NativeId, config: ReadableMap): PrepareMessageCallback? {
+        if (config.getMap("widevine")?.hasKey("prepareMessage") != true) {
+            return null
         }
+        val prepareMessageCallback = createPrepareCallback(
+            nativeId,
+            "onPrepareMessage",
+            preparedMessages,
+            preparedMessagesCondition,
+        )
+        return PrepareMessageCallback(prepareMessageCallback)
     }
 
     /**
@@ -143,20 +140,17 @@ class DrmModule(private val context: ReactApplicationContext) : ReactContextBase
      * @param nativeId Instance ID.
      * @param config `DrmConfig` config object sent from JS.
      */
-    private fun initPrepareLicense(nativeId: NativeId, config: ReadableMap) {
-        val widevineConfig = drmConfigs[nativeId]
-        val widevineJson = config.getMap("widevine")
-        if (widevineConfig != null && widevineJson != null && widevineJson.hasKey("prepareLicense")) {
-            val prepareLicense = createPrepareCallback(
-                nativeId,
-                "onPrepareLicense",
-                preparedLicenses,
-                preparedLicensesCondition,
-            )
-            widevineConfig.prepareLicenseCallback = PrepareLicenseCallback {
-                prepareLicense(it)
-            }
+    private fun buildPrepareLicense(nativeId: NativeId, config: ReadableMap): PrepareLicenseCallback? {
+        if (config.getMap("widevine")?.hasKey("prepareLicense") != true) {
+            return null
         }
+        val prepareLicense = createPrepareCallback(
+            nativeId,
+            "onPrepareLicense",
+            preparedLicenses,
+            preparedLicensesCondition,
+        )
+        return PrepareLicenseCallback(prepareLicense)
     }
 
     /**
@@ -181,10 +175,4 @@ class DrmModule(private val context: ReactApplicationContext) : ReactContextBase
             Base64.decode(result, Base64.NO_WRAP)
         }
     }
-
-    /**
-     * Helper function that returns the initialized `UIManager` instance.
-     */
-    private fun uiManager(): UIManagerModule? =
-        context.getNativeModule(UIManagerModule::class.java)
 }