bitmovin-player-react-native 0.3.1 → 0.5.0

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

@@ -0,0 +1,27 @@
+package com.bitmovin.player.reactnative.extensions
+
+/**
+ * Reflection helper for dynamically getting a property by name from a java object.
+ * @param propertyName Property name.
+ * @return A mutable property reference that can be used to get/set the prop's value.
+ */
+@Suppress("UNCHECKED_CAST")
+inline fun <reified T> Any?.getProperty(propertyName: String): T? = this?.let {
+    val getter = it::class.java.methods.firstOrNull { method ->
+        method.name == "get${propertyName.capitalized()}"
+    }
+    getter?.invoke(it) as? T
+}
+
+/**
+ * Reflection helper for dynamically setting a property value by name to a java object.
+ * @param propertyName Property name.
+ * @param value Value that will be set for the specified `propertyName`.
+ */
+@Suppress("UNCHECKED_CAST")
+inline fun <reified T> Any?.setProperty(propertyName: String, value: T) = this?.let {
+    val setter = it::class.java.methods.firstOrNull { method ->
+        method.name == "set${propertyName.capitalized()}"
+    }
+    setter?.invoke(it, value)
+}

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

@@ -0,0 +1,8 @@
+package com.bitmovin.player.reactnative.extensions
+
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+
+inline fun <reified T : ReactContextBaseJavaModule> ReactContext.getModule(): T? {
+    return getNativeModule(T::class.java)
+}

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

@@ -1,7 +1,6 @@
 package com.bitmovin.player.reactnative.extensions
 
-import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.*
 
 inline fun <reified T> ReadableArray.toList(): List<T?> = (0 until size()).map { i ->
     getDynamic(i).let {
@@ -12,7 +11,25 @@ inline fun <reified T> ReadableArray.toList(): List<T?> = (0 until size()).map {
             Int::class -> it.asInt() as T
             ReadableArray::class -> it.asArray() as T
             ReadableMap::class -> it.asMap() as T
+            WritableArray::class -> it.asArray() as T
+            WritableMap::class -> it.asMap() as T
             else -> null
         }
     }
 }
+
+inline fun <reified T> List<T>.toReadableArray(): ReadableArray = Arguments.createArray().apply {
+    forEach {
+        when (T::class) {
+            Boolean::class -> pushBoolean(it as Boolean)
+            String::class -> pushString(it as String)
+            Double::class -> pushDouble(it as Double)
+            Int::class -> pushInt(it as Int)
+            ReadableArray::class -> pushArray(it as ReadableArray)
+            ReadableMap::class -> pushMap(it as ReadableMap)
+            WritableArray::class -> pushArray(it as ReadableArray)
+            WritableMap::class -> pushMap(it as ReadableMap)
+            else -> pushNull()
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+package com.bitmovin.player.reactnative.extensions
+
+/**
+ * Returns a copy of this string with its first letter capitalized.
+ */
+fun String.capitalized(): String = this.replaceFirstChar {
+    it.uppercase()
+}

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

@@ -0,0 +1,19 @@
+package com.bitmovin.player.reactnative.extensions
+
+import com.facebook.react.bridge.WritableMap
+
+fun WritableMap.putInt(key: String, i: Int?) {
+    if (i == null) {
+        putNull(key)
+    } else {
+        putInt(key, i)
+    }
+}
+
+fun WritableMap.putDouble(key: String, d: Double?) {
+    if (d == null) {
+        putNull(key)
+    } else {
+        putDouble(key, d)
+    }
+}

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

@@ -0,0 +1,37 @@
+package com.bitmovin.player.reactnative.ui
+
+import com.bitmovin.player.api.ui.FullscreenHandler
+import com.bitmovin.player.reactnative.NativeId
+import com.bitmovin.player.reactnative.extensions.getModule
+import com.facebook.react.bridge.ReactApplicationContext
+
+class FullscreenHandlerBridge(
+    val context: ReactApplicationContext,
+    private val nativeId: NativeId
+) : FullscreenHandler {
+    override var isFullscreen = false
+
+    override fun onDestroy() {
+        // Do nothing
+    }
+
+    override fun onFullscreenExitRequested() {
+        context
+            .getModule<FullscreenHandlerModule>()
+            ?.requestExitFullscreen(nativeId)
+    }
+
+    override fun onFullscreenRequested() {
+        context
+            .getModule<FullscreenHandlerModule>()
+            ?.requestEnterFullscreen(nativeId)
+    }
+
+    override fun onPause() {
+        // Do nothing
+    }
+
+    override fun onResume() {
+        // Do nothing
+    }
+}

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

@@ -0,0 +1,73 @@
+package com.bitmovin.player.reactnative.ui
+
+import com.bitmovin.player.reactnative.NativeId
+import com.bitmovin.player.reactnative.Registry
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+
+private const val MODULE_NAME = "FullscreenHandlerModule"
+
+@ReactModule(name = MODULE_NAME)
+class FullscreenHandlerModule(private val context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
+    override fun getName() = MODULE_NAME
+
+    /**
+     * In-memory mapping from `nativeId`s to `FullscreenHandler` instances.
+     */
+    private val fullscreenHandler: Registry<FullscreenHandlerBridge> = mutableMapOf()
+
+    /**
+     * Module's local lock object used to sync calls between Kotlin and JS.
+     */
+    private val lock = ReentrantLock()
+
+    /**
+     *  Lock condition used to sync operations on the fullscreen handler.
+     */
+    private val fullscreenChangedCondition = lock.newCondition()
+
+    fun getInstance(nativeId: NativeId?): FullscreenHandlerBridge? = fullscreenHandler[nativeId]
+
+    fun requestEnterFullscreen(nativeId: NativeId) {
+        context.catalystInstance.callFunction(
+            "FullscreenBridge-${nativeId}",
+            "enterFullscreen",
+            Arguments.createArray() as NativeArray
+        )
+        lock.withLock {
+            fullscreenChangedCondition.await()
+        }
+    }
+
+    fun requestExitFullscreen(nativeId: NativeId) {
+        context.catalystInstance.callFunction(
+            "FullscreenBridge-${nativeId}",
+            "exitFullscreen",
+            Arguments.createArray() as NativeArray
+        )
+        lock.withLock {
+            fullscreenChangedCondition.await()
+        }
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    fun onFullscreenChanged(nativeId: NativeId, isFullscreenEnabled: Boolean) {
+        fullscreenHandler[nativeId]?.isFullscreen = isFullscreenEnabled
+        lock.withLock {
+            fullscreenChangedCondition.signal()
+        }
+    }
+
+    @ReactMethod
+    fun registerHandler(nativeId: NativeId) {
+        val fullscreenHandler = fullscreenHandler[nativeId] ?: FullscreenHandlerBridge(context, nativeId)
+        this.fullscreenHandler[nativeId] = fullscreenHandler
+    }
+
+    @ReactMethod
+    fun destroy(nativeId: NativeId) {
+        fullscreenHandler.remove(nativeId)
+    }
+}

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

@@ -0,0 +1,191 @@
+package com.bitmovin.player.reactnative.ui
+
+import android.app.PictureInPictureParams
+import android.content.pm.PackageManager
+import android.content.res.Configuration
+import android.graphics.Rect
+import android.os.Build
+import android.util.Rational
+import androidx.annotation.RequiresApi
+import androidx.appcompat.app.AppCompatActivity
+import com.bitmovin.player.api.ui.PictureInPictureHandler
+import com.facebook.react.bridge.ReactApplicationContext
+
+/**
+ * Delegate object for `RNPictureInPictureHandler`. It delegates all view logic that needs
+ * to be performed during each PiP state to this object.
+ */
+interface RNPictureInPictureDelegate {
+    /**
+     * Called whenever the handler's `isInPictureInPictureMode` changes to `true`.
+     */
+    fun onExitPictureInPicture()
+    /**
+     * Called whenever the handler's `isInPictureInPictureMode` changes to `false`.
+     */
+    fun onEnterPictureInPicture()
+    /**
+     * Called whenever the activity's PiP mode state changes with the new resources configuration.
+     */
+    fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean, newConfig: Configuration?)
+    /**
+     * Called whenever the handler needs to compute a new `sourceRectHint` for PiP params.
+     * The passed rect reference is expected to be fulfilled with the PlayerView's global visible
+     * rect.
+     */
+    fun setSourceRectHint(sourceRectHint: Rect)
+}
+
+/**
+ * Custom  PictureInPictureHandler` concrete implementation designed for React Native. It relies on
+ * React Native's application context to manage the application's PiP state. Can be subclassed in
+ * order to provide custom PiP capabilities.
+ */
+open class RNPictureInPictureHandler(val context: ReactApplicationContext): PictureInPictureHandler {
+    /**
+     * PiP delegate object that contains the view logic to be performed on each PiP state change.
+     */
+    private var delegate: RNPictureInPictureDelegate? = null
+
+    /**
+     * Whether the user has enabled PiP support via `isPictureInPictureEnabled` playback configuration in JS.
+     */
+    var isPictureInPictureEnabled = false
+
+    /**
+     * Whether this view is currently in PiP mode.
+     */
+    var isInPictureInPictureMode = false
+
+    /**
+     * Whether the current Android version supports PiP mode.
+     */
+    private val isPictureInPictureSupported: Boolean
+        get() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.N
+            && context.packageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)
+
+    /**
+     * Whether the picture in picture feature is available and enabled.
+     */
+    override val isPictureInPictureAvailable: Boolean
+        get() = isPictureInPictureEnabled && isPictureInPictureSupported
+
+    /**
+     * Whether this view is currently in PiP mode. Required for PictureInPictureHandler interface.
+     */
+    override val isPictureInPicture: Boolean
+        get() = isInPictureInPictureMode
+
+    /**
+     * Current React activity computed property.
+     */
+    private val currentActivity: AppCompatActivity?
+        get() {
+            if (context.hasCurrentActivity()) {
+                return context.currentActivity as AppCompatActivity
+            }
+            return null
+        }
+
+    /**
+     * Sets the new delegate object and update the activity's PiP parameters accordingly.
+     */
+    open fun setDelegate(delegate: RNPictureInPictureDelegate?) {
+        this.delegate = delegate
+        // Update the activity's PiP params once the delegate has been set.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O && isPictureInPictureAvailable) {
+            applyPictureInPictureParams()
+        }
+    }
+
+    /**
+     * Called whenever bitmovin's `PlayerView` needs to enter PiP mode.
+     */
+    override fun enterPictureInPicture() {
+        if (isPictureInPictureAvailable) {
+            currentActivity?.let {
+                it.supportActionBar?.hide()
+                it.enterPictureInPictureMode()
+            }
+        }
+    }
+
+    /**
+     * Called whenever bitmovin's `PlayerView` needs to exit PiP mode.
+     */
+    override fun exitPictureInPicture() {
+        if (isPictureInPictureAvailable) {
+            currentActivity?.supportActionBar?.show()
+        }
+    }
+
+    /**
+     * Called whenever the activity content resources have changed.
+     */
+    open fun onConfigurationChanged(newConfig: Configuration?) {
+        // PiP mode is supported since Android 7.0
+        if (isPictureInPictureAvailable) {
+            handlePictureInPictureModeChanges(newConfig)
+        }
+    }
+
+    /**
+     * Checks whether the current activity `isInPictureInPictureMode` has changed since the last lifecycle
+     * configuration change.
+     */
+    @RequiresApi(Build.VERSION_CODES.N)
+    private fun handlePictureInPictureModeChanges(newConfig: Configuration?) = currentActivity?.let {
+        if (isInPictureInPictureMode != it.isInPictureInPictureMode) {
+            delegate?.onPictureInPictureModeChanged(it.isInPictureInPictureMode, newConfig)
+            if (it.isInPictureInPictureMode) {
+                delegate?.onEnterPictureInPicture()
+            } else {
+                delegate?.onExitPictureInPicture()
+            }
+            isInPictureInPictureMode = it.isInPictureInPictureMode
+        }
+    }
+
+    /**
+     * Applies Android recommended PiP params on the current activity for smoother transitions.
+     *
+     * You can read more about the recommended settings for PiP here:
+     * - https://developer.android.com/develop/ui/views/picture-in-picture#smoother-transition
+     * - https://developer.android.com/develop/ui/views/picture-in-picture#smoother-exit
+     */
+    @RequiresApi(Build.VERSION_CODES.O)
+    private fun applyPictureInPictureParams() = currentActivity?.let {
+        // See also: https://developer.android.com/develop/ui/views/picture-in-picture#smoother-transition
+        val sourceRectHint = Rect()
+        delegate?.setSourceRectHint(sourceRectHint)
+        val ratio = Rational(16, 9)
+        val params = PictureInPictureParams.Builder()
+            .setAspectRatio(ratio)
+            .setSourceRectHint(sourceRectHint)
+        when {
+            // See also: https://developer.android.com/develop/ui/views/picture-in-picture#smoother-exit
+            Build.VERSION.SDK_INT >= Build.VERSION_CODES.S ->
+                params.setAutoEnterEnabled(true).setSeamlessResizeEnabled(true)
+            Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU ->
+                params.setExpandedAspectRatio(ratio)
+        }
+        it.setPictureInPictureParams(params.build())
+    }
+
+    /**
+     * Update source rect hint on activity's PiP params.
+     */
+    open fun updateSourceRectHint() {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O || !isPictureInPictureAvailable) {
+            return
+        }
+        currentActivity?.let {
+            val sourceRectHint = Rect()
+            delegate?.setSourceRectHint(sourceRectHint)
+            it.setPictureInPictureParams(
+                PictureInPictureParams.Builder()
+                    .setSourceRectHint(sourceRectHint)
+                    .build())
+        }
+    }
+}

package/ios/AnalyticsModule.m

@@ -0,0 +1,14 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_REMAP_MODULE(AnalyticsModule, AnalyticsModule, NSObject)
+
+RCT_EXTERN_METHOD(initWithConfig:(NSString *)nativeId config:(nullable id)config)
+RCT_EXTERN_METHOD(destroy:(NSString *)nativeId)
+RCT_EXTERN_METHOD(attach:(NSString *)nativeId playerId:(NSString *)playerId)
+RCT_EXTERN_METHOD(detach:(NSString *)nativeId)
+RCT_EXTERN_METHOD(setCustomDataOnce:(NSString *)nativeId json:(nullable id)json)
+RCT_EXTERN_METHOD(setCustomData:(NSString *)nativeId json:(nullable id)json)
+RCT_EXTERN_METHOD(getCustomData:(NSString *)nativeId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getUserId:(NSString *)nativeId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/AnalyticsModule.swift

@@ -0,0 +1,180 @@
+import BitmovinPlayer
+import BitmovinAnalyticsCollector
+
+@objc(AnalyticsModule)
+class AnalyticsModule: NSObject, RCTBridgeModule {
+    /// React bridge reference.
+    @objc var bridge: RCTBridge!
+
+    /// PlayerModule instance fetched from the bridge's registry
+    @objc var playerModule: PlayerModule? {
+        bridge.module(for: PlayerModule.self) as? PlayerModule
+    }
+
+    /// In-memory mapping from `nativeId`s to `BitmovinPlayerCollector` instances.
+    private var collectors: Registry<BitmovinPlayerCollector> = [:]
+
+    /// JS module name.
+    static func moduleName() -> String! {
+        "AnalyticsModule"
+    }
+
+    /// Module requires main thread initialization.
+    static func requiresMainQueueSetup() -> Bool {
+        true
+    }
+
+    /// Use `UIManager.addBlock` to enqueue module methods on UI thread.
+    var methodQueue: DispatchQueue! {
+        bridge.uiManager.methodQueue
+    }
+
+    /**
+     Retrieves a `BitmovinPlayerCollector` instance from the internal registry for the given `nativeId`.
+     - Parameter nativeId: Native Id of the collector instance.
+     - Returns: Collector instance associated with the `nativeId` or `nil`.
+     */
+    @objc func retrieve(_ nativeId: NativeId) -> BitmovinPlayerCollector? {
+        collectors[nativeId]
+    }
+
+    /**
+     Creates a new `BitmovinPlayerCollector` instance inside the internal registry using the provided `config` object.
+     - Parameter nativeId: ID to associate with the `BitmovinPlayerCollector` instance.
+     - Parameter config: `BitmovinAnalyticsConfig` object received from JS.
+     */
+    @objc(initWithConfig:config:)
+    func initWithConfig(_ nativeId: NativeId, config: Any?) {
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard let analyticsConfig = RCTConvert.analyticsConfig(config) else {
+                return
+            }
+            self?.collectors[nativeId] = BitmovinPlayerCollector(config: analyticsConfig)
+        }
+    }
+
+    /**
+     Detaches and removes the given `BitmovinPlayerCollector` from the internal registry.
+     - Parameter nativeId: Native Id of the collector instance.
+     */
+    @objc(destroy:)
+    func destroy(_ nativeId: NativeId) {
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            self?.collectors[nativeId]?.detachPlayer()
+            self?.collectors[nativeId] = nil
+        }
+    }
+
+    /**
+     Attaches a `BitmovinPlayerCollector` to the `Player` instance with native Id equal to `playerId`.
+     - Parameter nativeId: Native Id of the collector instance.
+     - Parameter playerId: Native Id of the player instance.
+     */
+    @objc(attach:playerId:)
+    func attach(_ nativeId: NativeId, playerId: NativeId) {
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard
+                let collector = self?.collectors[nativeId],
+                let player = self?.playerModule?.retrieve(playerId)
+            else {
+                return
+            }
+            collector.attachPlayer(player: player)
+        }
+    }
+
+    /**
+     Detaches the player object from a `BitmovinPlayerCollector` instance.
+     - Parameter nativeId: Native Id of the collector instance.
+     */
+    @objc(detach:)
+    func detach(_ nativeId: NativeId) {
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard let collector = self?.collectors[nativeId] else {
+                return
+            }
+            collector.detachPlayer()
+        }
+    }
+
+    /**
+     Updates the custom data config for a `BitmovinPlayerCollector` instance.
+     - Parameter nativeId: Native Id of the collector instance.
+     - Parameter json: Custom data config json.
+     */
+    @objc(setCustomDataOnce:json:)
+    func setCustomDataOnce(_ nativeId: NativeId, json: Any?) {
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard
+                let collector = self?.collectors[nativeId],
+                let customData = RCTConvert.analyticsCustomData(json)
+            else {
+                return
+            }
+            collector.setCustomDataOnce(customData: customData)
+        }
+    }
+
+    /**
+     Sets the custom data config for a `BitmovinPlayerCollector` instance.
+     - Parameter nativeId: Native Id of the collector instance.
+     - Parameter json: Custom data config json.
+     */
+    @objc(setCustomData:json:)
+    func setCustomData(_ nativeId: NativeId, json: Any?) {
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard
+                let collector = self?.collectors[nativeId],
+                let customData = RCTConvert.analyticsCustomData(json)
+            else {
+                return
+            }
+            collector.setCustomData(customData: customData)
+        }
+    }
+
+    /**
+     Gets the current custom data config for a `BitmovinPlayerCollector` instance.
+     - Parameter nativeId: Native Id of the the collector instance.
+     - Parameter resolver: JS promise resolver.
+     - Parameter rejecter: JS promise rejecter.
+     */
+    @objc(getCustomData:resolver:rejecter:)
+    func getCustomData(
+        _ nativeId: NativeId,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard
+                let collector = self?.collectors[nativeId],
+                let customData = RCTConvert.toJson(analyticsCustomData: collector.getCustomData())
+            else {
+                reject("[AnalyticsModule]", "Could not find analytics collector with ID (\(nativeId))", nil)
+                return
+            }
+            resolve(customData)
+        }
+    }
+
+    /**
+     Gets the current user Id for a `BitmovinPlayerCollector` instance.
+     - Parameter nativeId: Native Id of the the collector instance.
+     - Parameter resolver: JS promise resolver.
+     - Parameter rejecter: JS promise rejecter.
+     */
+    @objc(getUserId:resolver:rejecter:)
+    func getUserId(
+        _ nativeId: NativeId,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard let collector = self?.collectors[nativeId] else {
+                reject("[AnalyticsModule]", "Could not find analytics collector with ID (\(nativeId))", nil)
+                return
+            }
+            resolve(collector.getUserId())
+        }
+    }
+}

package/ios/AudioSessionModule.m

@@ -0,0 +1,10 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_REMAP_MODULE(AudioSessionModule, AudioSessionModule, NSObject)
+
+RCT_EXTERN_METHOD(
+    setCategory:(NSString *)category
+    resolver:(RCTPromiseResolveBlock)resolve
+    rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/AudioSessionModule.swift

@@ -0,0 +1,65 @@
+import AVFAudio
+
+@objc(AudioSessionModule)
+class AudioSessionModule: NSObject, RCTBridgeModule {
+    // Run this module methods on main thread.
+    var methodQueue: DispatchQueue! {
+        DispatchQueue.main
+    }
+
+    /// JS module name.
+    static func moduleName() -> String! {
+        "AudioSessionModule"
+    }
+
+    // Requires module initialization.
+    static func requiresMainQueueSetup() -> Bool {
+        true
+    }
+
+    /**
+     Sets the audio session’s category.
+     - Parameter category: Category string.
+     - Parameter resolver: JS promise resolver block.
+     - Parameter rejecter: JS promise rejecter block.
+     */
+    @objc func setCategory(
+        _ category: String,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        if let category = parseCategory(category) {
+            do {
+                try AVAudioSession.sharedInstance().setCategory(category)
+                resolve(nil)
+            } catch {
+                reject("\((error as NSError).code)", error.localizedDescription, error as NSError)
+            }
+        } else {
+            let error = RCTErrorWithMessage("Unknown audio session category: \(category)") as NSError
+            reject("\(error.code)", error.localizedDescription, error)
+        }
+    }
+
+    /**
+     Parse any category string to an `AVAudioSession.Category` type.
+     */
+    private func parseCategory(_ category: String) -> AVAudioSession.Category? {
+        switch (category) {
+        case "ambient":
+            return .ambient
+        case "multiRoute":
+            return .multiRoute
+        case "playAndRecord":
+            return .playAndRecord
+        case "playback":
+            return .playback
+        case "record":
+            return .record
+        case "soloAmbient":
+            return .soloAmbient
+        default:
+            return nil
+        }
+    }
+}