Implement BufferAPI via Player.buffer

CHANGELOG.md

@@ -12,6 +12,7 @@
 - `PlayerView.isPictureInPictureRequested` to programatically create a Picture in Picture request
 - `PlayerView.scalingMode` to allow changing the video scaling mode
 - `PlayerViewConfig` with a `UiConfig` to the `PlayerView` to enable configuration of the visual presentation and behaviour
+- `Player.buffer` namespace to control buffer preferences and to query the current buffer state.
 
 ### Changed
 

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

@@ -0,0 +1,73 @@
+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.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.UIManagerModule
+
+private const val MODULE_NAME = "BufferModule"
+
+@ReactModule(name = MODULE_NAME)
+class BufferModule(private val context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
+    /**
+     * Collection of [BufferLevel] objects
+     * @param audio [BufferLevel] for [MediaType.Audio].
+     * @param video [BufferLevel] for [MediaType.Video].
+     */
+    data class RNBufferLevels(val audio: BufferLevel, val video: BufferLevel)
+
+    /**
+     * JS exported module name.
+     */
+    override fun getName() = MODULE_NAME
+
+    /**
+     * Gets the [buffer level][BufferLevel] from the Player
+     * @param nativeId Target player id.
+     * @param type The [type of buffer][JsonConverter.toBufferType] to return the level for.
+     * @param promise JS promise object.
+     */
+    @ReactMethod
+    fun getLevel(nativeId: NativeId, type: Int, promise: Promise) {
+        uiManager()?.addUIBlock { _ ->
+            val player = playerModule()?.getPlayer(nativeId) ?: return@addUIBlock
+            val bufferType = JsonConverter.toBufferType(type)
+            val bufferLevels = RNBufferLevels(
+                player.buffer.getLevel(bufferType, MediaType.Audio),
+                player.buffer.getLevel(bufferType, MediaType.Video),
+            )
+            JsonConverter.fromRNBufferLevels(bufferLevels)?.let {
+                promise.resolve(it)
+            }
+        }
+    }
+
+    /**
+     * Sets the target buffer level for the chosen buffer type across all media types.
+     * @param nativeId Target player id.
+     * @param type The type of the buffer to set the target level for.
+     * @param value The value to set.
+     */
+    @ReactMethod
+    fun setTargetLevel(nativeId: NativeId, type: Int, value: Double) {
+        uiManager()?.addUIBlock { _ ->
+            val player = playerModule()?.getPlayer(nativeId) ?: return@addUIBlock
+            val bufferType = JsonConverter.toBufferType(type)
+            player.buffer.setTargetLevel(bufferType, 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)
+}

android/src/main/java/com/bitmovin/player/reactnative/RNPlayerViewPackage.kt

@@ -29,6 +29,7 @@ class RNPlayerViewPackage : ReactPackage {
             FullscreenHandlerModule(reactContext),
             CustomMessageHandlerModule(reactContext),
             BitmovinCastManagerModule(reactContext),
+            BufferModule(reactContext),
         )
     }
 

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

@@ -19,14 +19,17 @@ import com.bitmovin.player.api.advertising.AdSource
 import com.bitmovin.player.api.advertising.AdSourceType
 import com.bitmovin.player.api.advertising.AdvertisingConfig
 import com.bitmovin.player.api.buffer.BufferConfig
+import com.bitmovin.player.api.buffer.BufferLevel
 import com.bitmovin.player.api.buffer.BufferMediaTypeConfig
+import com.bitmovin.player.api.buffer.BufferType
 import com.bitmovin.player.api.casting.RemoteControlConfig
 import com.bitmovin.player.api.drm.WidevineConfig
 import com.bitmovin.player.api.event.PlayerEvent
 import com.bitmovin.player.api.event.SourceEvent
 import com.bitmovin.player.api.event.data.CastPayload
 import com.bitmovin.player.api.event.data.SeekPosition
 import com.bitmovin.player.api.media.AdaptationConfig
+import com.bitmovin.player.api.media.MediaType
 import com.bitmovin.player.api.media.audio.AudioTrack
 import com.bitmovin.player.api.media.subtitle.SubtitleTrack
 import com.bitmovin.player.api.media.thumbnail.Thumbnail
@@ -44,6 +47,7 @@ import com.bitmovin.player.api.ui.ScalingMode
 import com.bitmovin.player.api.ui.StyleConfig
 import com.bitmovin.player.api.ui.UiConfig
 import com.bitmovin.player.reactnative.BitmovinCastManagerOptions
+import com.bitmovin.player.reactnative.BufferModule
 import com.bitmovin.player.reactnative.extensions.getBooleanOrNull
 import com.bitmovin.player.reactnative.extensions.getName
 import com.bitmovin.player.reactnative.extensions.getOrDefault
@@ -1160,6 +1164,59 @@ class JsonConverter {
                     ?: true,
             ),
         )
+
+        @JvmStatic
+        fun fromBufferLevel(bufferLevel: BufferLevel?): WritableMap? {
+            if (bufferLevel == null) {
+                return null
+            }
+
+            return Arguments.createMap().apply {
+                putDouble("level", bufferLevel.level)
+                putDouble("targetLevel", bufferLevel.targetLevel)
+                putInt(
+                    "media",
+                    when (bufferLevel.media) {
+                        MediaType.Audio -> 0
+                        MediaType.Video -> 1
+                    },
+                )
+                putInt(
+                    "type",
+                    when (bufferLevel.type) {
+                        BufferType.ForwardDuration -> 0
+                        BufferType.BackwardDuration -> 1
+                    },
+                )
+            }
+        }
+
+        @JvmStatic
+        fun fromRNBufferLevels(bufferLevels: BufferModule.RNBufferLevels?): WritableMap? {
+            if (bufferLevels == null) {
+                return null
+            }
+
+            return Arguments.createMap().apply {
+                putMap("audio", fromBufferLevel(bufferLevels.audio))
+                putMap("video", fromBufferLevel(bufferLevels.video))
+            }
+        }
+
+        /**
+         * Maps an integer value into the corresponding [BufferType] value.
+         *
+         * Currently `0` is mapped to [BufferType.ForwardDuration], and `1` to [BufferType.BackwardDuration].
+         * Other values fall back to [BufferType.ForwardDuration]
+         * @param value Integer value representing the [BufferType].
+         * @return The [BufferType] corresponding to [value].
+         */
+        @JvmStatic
+        fun toBufferType(value: Int?): BufferType = when (value) {
+            0 -> BufferType.ForwardDuration
+            1 -> BufferType.BackwardDuration
+            else -> BufferType.ForwardDuration
+        }
     }
 }
 

ios/BufferModule.m

@@ -0,0 +1,8 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_REMAP_MODULE(BufferModule, BufferModule, NSObject)
+
+RCT_EXTERN_METHOD(getLevel:(NSString *)nativeId type:(nonnull NSNumber *)type resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(setTargetLevel:(NSString *)nativeId type:(nonnull NSNumber *)type value:(nonnull NSNumber *)value)
+
+@end

ios/BufferModule.swift

@@ -0,0 +1,89 @@
+import BitmovinPlayer
+
+@objc(BufferModule)
+public class BufferModule: NSObject, RCTBridgeModule {
+    /**
+     * Collection of `BufferLevel` objects
+     * - Parameter audio: `BufferLevel` for `MediaType.Audio`.
+     * - Parameter video: `BufferLevel` for `MediaType.Video`.
+     */
+    internal struct RNBufferLevels {
+        let audio: BufferLevel
+        let video: BufferLevel
+    }
+
+    // swiftlint:disable:next implicitly_unwrapped_optional
+    @objc public var bridge: RCTBridge!
+
+    /// PlayerModule instance fetched from the bridge's registry
+    @objc var playerModule: PlayerModule? {
+        bridge.module(for: PlayerModule.self) as? PlayerModule
+    }
+
+    // swiftlint:disable:next implicitly_unwrapped_optional
+    public static func moduleName() -> String! {
+        "BufferModule"
+    }
+
+    /// Module requires main thread initialization.
+    public static func requiresMainQueueSetup() -> Bool {
+        true
+    }
+
+    // swiftlint:disable:next implicitly_unwrapped_optional
+    public var methodQueue: DispatchQueue! {
+        bridge.uiManager.methodQueue
+    }
+
+    /**
+     - Gets the `BufferLevel` from the Player
+     - Parameter nativeId: Native Id of the the player instance.
+     - Parameter type: The type of buffer to return the level for.
+     - Parameter resolver: JS promise resolver.
+     - Parameter rejecter: JS promise rejecter.
+     */
+    @objc(getLevel:type:resolver:rejecter:)
+    func getLevel(
+        _ playerId: NativeId,
+        type: NSNumber,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard let bufferApi = self?.playerModule?.retrieve(playerId)?.buffer else {
+                reject("[BufferModule]", "Could not find player with ID (\(playerId))", nil)
+                return
+            }
+            guard let bufferType = RCTConvert.bufferType(type) else {
+                reject("[BufferModule]", "Invalid buffer type", nil)
+                return
+            }
+
+            let level = bufferApi.getLevel(bufferType)
+            let bufferLevels = RNBufferLevels(audio: level, video: level)
+            resolve(RCTConvert.toJson(bufferLevels: bufferLevels))
+        }
+    }
+
+    /**
+     * Sets the target level in seconds for the forward buffer.
+     - Parameter nativeId: Target player id.
+     - Parameter type: The type of the buffer to set the target level for.
+     - Parameter value: The value to set.
+     */
+    @objc(setTargetLevel:type:value:)
+    func setTargetLevel(_ playerId: NativeId, type: NSNumber, value: NSNumber) {
+        let targetLevel = value.doubleValue
+        bridge.uiManager.addUIBlock { [weak self] _, _ in
+            guard
+                let bufferApi = self?.playerModule?.retrieve(playerId)?.buffer,
+                let bufferType = RCTConvert.bufferType(type),
+                bufferType == .forwardDuration
+            else {
+                return
+            }
+
+            bufferApi.setTargetLevel(targetLevel)
+        }
+    }
+}

ios/RCTConvert+BitmovinPlayer.swift

@@ -1138,6 +1138,71 @@ extension RCTConvert {
             )
         )
     }
+
+    /**
+     * Utility method to instantiate a `BufferType` from an Integer.
+     * Currently `0` is mapped to `BufferType.forwardDuration`, and `1` to `BufferType.backwardDuration`.
+     * Other values fall back to `BufferType.forwardDuration`
+     * - Parameter value: Integer value representing the `BufferType`.
+     * - Returns: The `BufferType` corresponding to `value`.
+     */
+    static func bufferType(_ value: NSNumber?) -> BufferType? {
+        guard let value = value as? Int else {
+            return nil
+        }
+
+        switch value {
+        case 0:
+            return .forwardDuration
+        case 1:
+            return .backwardDuration
+        default:
+            return .forwardDuration
+        }
+    }
+
+    /**
+     Utility method to get a json dictionary value from a `BufferLevel` object.
+     - Parameter bufferLevel: The `BufferLevel` to convert to json format.
+     - Parameter mediaType: The `MediaType` value to pass through.
+     - Returns: The generated json dictionary.
+     */
+    static func toJson(bufferLevel: BufferLevel?, mediaType: Int) -> [String: Any]? {
+        guard let bufferLevel else {
+            return nil
+        }
+
+        let type: Int
+        switch bufferLevel.type {
+        case .forwardDuration:
+            type = 0
+        case .backwardDuration:
+            type = 1
+        }
+
+        return [
+            "level": bufferLevel.level,
+            "targetLevel": bufferLevel.targetLevel,
+            "media": mediaType,
+            "type": type
+        ]
+    }
+
+    /**
+     Utility method to get a json dictionary value from a `BufferModule.RNBufferLevels` object.
+     - Parameter bufferLevels: The `BufferModule.RNBufferLevels` to convert to json format.
+     - Returns: The generated json dictionary.
+     */
+    static func toJson(bufferLevels: BufferModule.RNBufferLevels?) -> [String: Any]? {
+        guard let bufferLevels else {
+            return nil
+        }
+
+        return [
+            "audio": toJson(bufferLevel: bufferLevels.audio, mediaType: 0),
+            "video": toJson(bufferLevel: bufferLevels.video, mediaType: 1),
+        ]
+    }
 }
 /**
  * React native specific PlayerViewConfig.