bitmovin-player-react-native 0.3.0 → 0.4.0

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

@@ -1,7 +1,11 @@
 package com.bitmovin.player.reactnative.converter
 
+import com.bitmovin.player.api.DeviceDescription.DeviceName
+import com.bitmovin.player.api.DeviceDescription.ModelName
 import com.bitmovin.player.api.PlaybackConfig
 import com.bitmovin.player.api.PlayerConfig
+import com.bitmovin.player.api.TweaksConfig
+import com.bitmovin.player.api.advertising.*
 import com.bitmovin.player.api.drm.WidevineConfig
 import com.bitmovin.player.api.event.PlayerEvent
 import com.bitmovin.player.api.event.SourceEvent
@@ -11,6 +15,10 @@ import com.bitmovin.player.api.source.Source
 import com.bitmovin.player.api.source.SourceConfig
 import com.bitmovin.player.api.source.SourceType
 import com.bitmovin.player.reactnative.extensions.getName
+import com.bitmovin.player.reactnative.extensions.putInt
+import com.bitmovin.player.reactnative.extensions.putDouble
+import com.bitmovin.player.reactnative.extensions.toList
+import com.bitmovin.player.reactnative.extensions.toReadableArray
 import com.facebook.react.bridge.*
 import java.util.UUID
 
@@ -33,20 +41,146 @@ class JsonConverter {
                 PlayerConfig()
             }
             if (json.hasKey("playbackConfig")) {
-                var playbackConfigJson = json.getMap("playbackConfig")
-                if (playbackConfigJson?.hasKey("isAutoplayEnabled") == true) {
-                    playerConfig.playbackConfig.isAutoplayEnabled = playbackConfigJson.getBoolean("isAutoplayEnabled")
+                toPlaybackConfig(json.getMap("playbackConfig"))?.let {
+                    playerConfig.playbackConfig = it
                 }
-                if(playbackConfigJson?.hasKey("isMuted") == true) {
-                    playerConfig.playbackConfig.isMuted = playbackConfigJson.getBoolean("isMuted")
+            }
+            if (json.hasKey("tweaksConfig")) {
+                toTweaksConfig(json.getMap("tweaksConfig"))?.let {
+                    playerConfig.tweaksConfig = it
                 }
-                if(playbackConfigJson?.hasKey("isTimeShiftEnabled") == true) {
-                    playerConfig.playbackConfig.isTimeShiftEnabled = playbackConfigJson.getBoolean("isTimeShiftEnabled")
+            }
+            if (json.hasKey("advertisingConfig")) {
+                toAdvertisingConfig(json.getMap("advertisingConfig"))?.let {
+                    playerConfig.advertisingConfig = it
                 }
             }
             return playerConfig
         }
 
+        /**
+         * Converts any JS object into a `PlaybackConfig` object.
+         * @param json JS object representing the `PlaybackConfig`.
+         * @return The generated `PlaybackConfig` if successful, `null` otherwise.
+         */
+        @JvmStatic
+        fun toPlaybackConfig(json: ReadableMap?): PlaybackConfig? {
+            if (json == null) {
+                return null
+            }
+            val playbackConfig = PlaybackConfig()
+            if (json.hasKey("isAutoplayEnabled")) {
+                playbackConfig.isAutoplayEnabled = json.getBoolean("isAutoplayEnabled")
+            }
+            if (json.hasKey("isMuted")) {
+                playbackConfig.isMuted = json.getBoolean("isMuted")
+            }
+            if (json.hasKey("isTimeShiftEnabled")) {
+                playbackConfig.isTimeShiftEnabled = json.getBoolean("isTimeShiftEnabled")
+            }
+            return playbackConfig
+        }
+
+        /**
+         * Converts any JS object into a `TweaksConfig` object.
+         * @param json JS object representing the `TweaksConfig`.
+         * @return The generated `TweaksConfig` if successful, `null` otherwise.
+         */
+        @JvmStatic
+        fun toTweaksConfig(json: ReadableMap?): TweaksConfig? {
+            if (json == null) {
+                return null
+            }
+            val tweaksConfig = TweaksConfig()
+            if (json.hasKey("timeChangedInterval")) {
+                tweaksConfig.timeChangedInterval = json.getDouble("timeChangedInterval")
+            }
+            if (json.hasKey("bandwidthEstimateWeightLimit")) {
+                tweaksConfig.bandwidthEstimateWeightLimit = json.getInt("bandwidthEstimateWeightLimit")
+            }
+            if (json.hasKey("devicesThatRequireSurfaceWorkaround")) {
+                val devices = json.getMap("devicesThatRequireSurfaceWorkaround")
+                val deviceNames = devices?.getArray("deviceNames")
+                    ?.toList<String>()
+                    ?.mapNotNull { it }
+                    ?.map { DeviceName(it) }
+                    ?: emptyList()
+                val modelNames = devices?.getArray("modelNames")
+                    ?.toList<String>()
+                    ?.mapNotNull { it }
+                    ?.map { ModelName(it) }
+                    ?: emptyList()
+                tweaksConfig.devicesThatRequireSurfaceWorkaround = deviceNames + modelNames
+            }
+            if (json.hasKey("languagePropertyNormalization")) {
+                tweaksConfig.languagePropertyNormalization = json.getBoolean("languagePropertyNormalization")
+            }
+            if (json.hasKey("localDynamicDashWindowUpdateInterval")) {
+                tweaksConfig.localDynamicDashWindowUpdateInterval = json.getDouble("localDynamicDashWindowUpdateInterval")
+            }
+            if (json.hasKey("shouldApplyTtmlRegionWorkaround")) {
+                tweaksConfig.shouldApplyTtmlRegionWorkaround = json.getBoolean("shouldApplyTtmlRegionWorkaround")
+            }
+            if (json.hasKey("useDrmSessionForClearPeriods")) {
+                tweaksConfig.useDrmSessionForClearPeriods = json.getBoolean("useDrmSessionForClearPeriods")
+            }
+            if (json.hasKey("useDrmSessionForClearSources")) {
+                tweaksConfig.useDrmSessionForClearSources = json.getBoolean("useDrmSessionForClearSources")
+            }
+            if (json.hasKey("useFiletypeExtractorFallbackForHls")) {
+                tweaksConfig.useFiletypeExtractorFallbackForHls = json.getBoolean("useFiletypeExtractorFallbackForHls")
+            }
+            return tweaksConfig
+        }
+
+        /**
+         * Converts any JS object into an `AdvertisingConfig` object.
+         * @param json JS object representing the `AdvertisingConfig`.
+         * @return The generated `AdvertisingConfig` if successful, `null` otherwise.
+         */
+        @JvmStatic
+        fun toAdvertisingConfig(json: ReadableMap?): AdvertisingConfig? = json?.getArray("schedule")
+            ?.toList<ReadableMap>()
+            ?.mapNotNull(::toAdItem)
+            ?.let { AdvertisingConfig(it) }
+
+        /**
+         * Converts any JS object into an `AdItem` object.
+         * @param json JS object representing the `AdItem`.
+         * @return The generated `AdItem` if successful, `null` otherwise.
+         */
+        @JvmStatic
+        fun toAdItem(json: ReadableMap?): AdItem? {
+            val sources = json?.getArray("sources")
+                ?.toList<ReadableMap>()
+                ?.mapNotNull(::toAdSource)
+                ?.toTypedArray()
+                ?: return null
+            return AdItem(sources, json?.getString("position") ?: "pre")
+        }
+
+        /**
+         * Converts any JS object into an `AdSource` object.
+         * @param json JS object representing the `AdSource`.
+         * @return The generated `AdSource` if successful, `null` otherwise.
+         */
+        @JvmStatic
+        fun toAdSource(json: ReadableMap?): AdSource? = json?.getString("tag")?.let {
+            AdSource(toAdSourceType(json.getString("type")), it)
+        }
+
+        /**
+         * Converts any JS string into an `AdSourceType` enum value.
+         * @param json JS string representing the `AdSourceType`.
+         * @return The generated `AdSourceType`.
+         */
+        @JvmStatic
+        fun toAdSourceType(json: String?): AdSourceType = when (json) {
+            "ima" -> AdSourceType.Ima
+            "progressive" -> AdSourceType.Progressive
+            else -> AdSourceType.Unknown
+        }
+
         /**
          * Converts an arbitrary `json` to `SourceConfig`.
          * @param json JS object representing the `SourceConfig`.
@@ -193,6 +327,55 @@ class JsonConverter {
                 json.putMap("from", fromSeekPosition(event.from))
                 json.putMap("to", fromSeekPosition(event.to))
             }
+            if (event is PlayerEvent.PictureInPictureAvailabilityChanged) {
+                json.putBoolean("isPictureInPictureAvailable", event.isPictureInPictureAvailable)
+            }
+            if (event is PlayerEvent.AdBreakFinished) {
+                json.putMap("adBreak", fromAdBreak(event.adBreak))
+            }
+            if (event is PlayerEvent.AdBreakStarted) {
+                json.putMap("adBreak", fromAdBreak(event.adBreak))
+            }
+            if (event is PlayerEvent.AdClicked) {
+                json.putString("clickThroughUrl", event.clickThroughUrl)
+            }
+            if (event is PlayerEvent.AdError) {
+                json.putInt("code", event.code)
+                json.putString("message", event.message)
+                json.putMap("adConfig", fromAdConfig(event.adConfig))
+                json.putMap("adItem", fromAdItem(event.adItem))
+            }
+            if (event is PlayerEvent.AdFinished) {
+                json.putMap("ad", fromAd(event.ad))
+            }
+            if (event is PlayerEvent.AdManifestLoad) {
+                json.putMap("adBreak", fromAdBreak(event.adBreak))
+                json.putMap("adConfig", fromAdConfig(event.adConfig))
+            }
+            if (event is PlayerEvent.AdManifestLoaded) {
+                json.putMap("adBreak", fromAdBreak(event.adBreak))
+                json.putMap("adConfig", fromAdConfig(event.adConfig))
+                json.putDouble("downloadTime", event.downloadTime.toDouble())
+            }
+            if (event is PlayerEvent.AdQuartile) {
+                json.putString("quartile", fromAdQuartile(event.quartile))
+            }
+            if (event is PlayerEvent.AdScheduled) {
+                json.putInt("numberOfAds", event.numberOfAds)
+            }
+            if (event is PlayerEvent.AdSkipped) {
+                json.putMap("ad", fromAd(event.ad))
+            }
+            if (event is PlayerEvent.AdStarted) {
+                json.putMap("ad", fromAd(event.ad))
+                json.putString("clickThroughUrl", event.clickThroughUrl)
+                json.putString("clientType", fromAdSourceType(event.clientType))
+                json.putDouble("duration", event.duration)
+                json.putInt("indexInQueue", event.indexInQueue)
+                json.putString("position", event.position)
+                json.putDouble("skipOffset", event.skipOffset)
+                json.putDouble("timeOffset", event.timeOffset)
+            }
             return json
         }
 
@@ -301,5 +484,116 @@ class JsonConverter {
             }
             return mimeType.split("/").last()
         }
+
+        /**
+         * Converts any `AdBreak` object into its json representation.
+         * @param adBreak `AdBreak` object.
+         * @return The produced JS object.
+         */
+        @JvmStatic
+        fun fromAdBreak(adBreak: AdBreak?): WritableMap? = adBreak?.let {
+            Arguments.createMap().apply {
+                putArray("ads", it.ads.mapNotNull(::fromAd).toReadableArray())
+                putString("id", it.id)
+                putDouble("scheduleTime", it.scheduleTime)
+            }
+        }
+
+        /**
+         * Converts any `Ad` object into its json representation.
+         * @param ad `Ad` object.
+         * @return The produced JS object.
+         */
+        @JvmStatic
+        fun fromAd(ad: Ad?): WritableMap? = ad?.let {
+            Arguments.createMap().apply {
+                putString("clickThroughUrl", it.clickThroughUrl)
+                putMap("data", fromAdData(it.data))
+                putInt("height", it.height)
+                putString("id", it.id)
+                putBoolean("isLinear", it.isLinear)
+                putString("mediaFileUrl", it.mediaFileUrl)
+                putInt("width", it.width)
+            }
+        }
+
+        /**
+         * Converts any `AdData` object into its json representation.
+         * @param adData `AdData` object.
+         * @return The produced JS object.
+         */
+        @JvmStatic
+        fun fromAdData(adData: AdData?): WritableMap? = adData?.let {
+            Arguments.createMap().apply {
+                putInt("bitrate", it.bitrate)
+                putInt("maxBitrate", it.maxBitrate)
+                putString("mimeType", it.mimeType)
+                putInt("minBitrate", it.minBitrate)
+            }
+        }
+
+        /**
+         * Converts any `AdConfig` object into its json representation.
+         * @param adConfig `AdConfig` object.
+         * @return The produced JS object.
+         */
+        @JvmStatic
+        fun fromAdConfig(adConfig: AdConfig?): WritableMap? = adConfig?.let {
+            Arguments.createMap().apply {
+                putDouble("replaceContentDuration", it.replaceContentDuration)
+            }
+        }
+
+        /**
+         * Converts any `AdItem` object into its json representation.
+         * @param adItem `AdItem` object.
+         * @return The produced JS object.
+         */
+        @JvmStatic
+        fun fromAdItem(adItem: AdItem?): WritableMap? = adItem?.let {
+            Arguments.createMap().apply {
+                putString("position", it.position)
+                putArray("sources", it.sources.mapNotNull(::fromAdSource).toReadableArray())
+            }
+        }
+
+        /**
+         * Converts any `AdSource` object into its json representation.
+         * @param adSource `AdSource` object.
+         * @return The produced JS object.
+         */
+        @JvmStatic
+        fun fromAdSource(adSource: AdSource?): WritableMap? = adSource?.let {
+            Arguments.createMap().apply {
+                putString("tag", it.tag)
+                putString("type", fromAdSourceType(it.type))
+            }
+        }
+
+        /**
+         * Converts any `AdSourceType` value into its json representation.
+         * @param adSourceType `AdSourceType` value.
+         * @return The produced JS string.
+         */
+        @JvmStatic
+        fun fromAdSourceType(adSourceType: AdSourceType?): String? = when (adSourceType) {
+            AdSourceType.Ima -> "ima"
+            AdSourceType.Unknown -> "unknown"
+            AdSourceType.Progressive -> "progressive"
+            else -> null
+        }
+
+        /**
+         * Converts any `AdQuartile` value into its json representation.
+         * @param adQuartile `AdQuartile` value.
+         * @return The produced JS string.
+         */
+        @JvmStatic
+        fun fromAdQuartile(adQuartile: AdQuartile?): String? = when (adQuartile) {
+            AdQuartile.FirstQuartile -> "first"
+            AdQuartile.MidPoint -> "mid_point"
+            AdQuartile.ThirdQuartile -> "third"
+            else -> null
+        }
     }
 }

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

@@ -0,0 +1,35 @@
+package com.bitmovin.player.reactnative.extensions
+
+import com.facebook.react.bridge.*
+
+inline fun <reified T> ReadableArray.toList(): List<T?> = (0 until size()).map { i ->
+    getDynamic(i).let {
+        when (T::class) {
+            Boolean::class -> it.asBoolean() as T
+            String::class -> it.asString() as T
+            Double::class -> it.asDouble() as T
+            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/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/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/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
+        }
+    }
+}