@wscsports/blaze-rtn-sdk 1.5.4 → 1.18.0

package/README.md

@@ -3,6 +3,10 @@
 # Introduction 
 Welcome to WSC Sports React Native SDK.
 
+## Platform requirements
+
+- iOS: 15.0+
+
 # Getting Started
 Further details can be found here:<br/>
 [Getting Started](https://dev.wsc-sports.com/docs/react-native-sdk-init)

package/android/build.gradle

@@ -6,7 +6,7 @@ buildscript {
         blaze_default_compileSdkVersion = 35
         blaze_default_minSdkVersion = 24
         blaze_default_kotlin_version = '2.0.21'
-        blazesdk_version = '1.11.6'
+        blazesdk_version = '1.18.0'
         blaze_gson_version = '2.10.1'
     }
 

package/android/src/main/java/com/blaze/rtnblazesdk/BlazeSdkModule.kt

@@ -2,32 +2,51 @@ package com.blaze.rtnblazesdk
 
 import android.util.Log
 import com.blaze.blazesdk.analytics.models.BlazeAnalyticsEvent
+import com.blaze.blazesdk.delegates.BlazeCastingDelegate
+import com.blaze.blazesdk.delegates.BlazeCastingState
+import com.blaze.blazesdk.delegates.BlazePipDelegate
+import com.blaze.blazesdk.delegates.BlazePipState
+import com.blaze.blazesdk.delegates.BlazeFollowEntitiesDelegate
 import com.blaze.blazesdk.delegates.BlazePlayerEntryPointDelegate
 import com.blaze.blazesdk.delegates.BlazeSDKDelegate
 import com.blaze.blazesdk.delegates.models.BlazeCTAActionType
+import com.blaze.blazesdk.delegates.models.BlazeFollowEntityClickedParams
+import com.blaze.blazesdk.delegates.models.BlazePlaybackModificationRequest
+import com.blaze.blazesdk.delegates.models.BlazePlaybackModificationResponse
+import com.blaze.blazesdk.style.shared.models.BlazePlayerCustomActionButtonParams
 import com.blaze.blazesdk.delegates.models.BlazePlayerEvent
 import com.blaze.blazesdk.delegates.models.BlazePlayerType
+import com.blaze.blazesdk.follow.models.BlazeFollowEntity
 import com.blaze.blazesdk.external_modules.BlazeExternalModulesBinder
+import com.blaze.blazesdk.features.moments.models.configuration.BlazeMomentsLoopBehavior
+import com.blaze.blazesdk.features.moments.models.configuration.BlazeMomentsPlaybackConfiguration
+import com.blaze.blazesdk.features.search.models.BlazeSearchScreenParams
 import com.blaze.blazesdk.features.shared.models.ui_shared.BlazeLinkActionHandleType
 import com.blaze.blazesdk.prefetch.models.BlazeCachingLevel
 import com.blaze.blazesdk.shared.BlazeSDK
 import com.blaze.blazesdk.shared.models.BlazeEntryPointTriggerSource
 import com.blaze.blazesdk.shared.results.BlazeResult
 import com.blaze.rtnblazesdk.events.SdkModuleJsEvent
+import com.blaze.rtnblazesdk.shared.blazeAsyncBridge
+import com.blaze.rtnblazesdk.shared.callJSMethod
 import com.blaze.rtnblazesdk.utils.extractCachingLevel
 import com.blaze.rtnblazesdk.utils.extractDataSource
 import com.blaze.rtnblazesdk.utils.extractMomentsPlayerStyle
 import com.blaze.rtnblazesdk.utils.extractStoriesPlayerStyle
+import com.blaze.rtnblazesdk.utils.extractMomentsPlaybackConfiguration
+import com.blaze.rtnblazesdk.utils.extractVideosPlaybackConfiguration
 import com.blaze.rtnblazesdk.utils.extractVideosPlayerStyle
 import com.blaze.rtnblazesdk.utils.getBooleanOrNull
 import com.blaze.rtnblazesdk.utils.handleResult
 import com.blaze.rtnblazesdk.utils.rejectWith
 import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.react.bridge.NoSuchKeyException
+import com.facebook.react.bridge.Arguments
 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.ReadableArray
 import com.facebook.react.bridge.ReadableMap
 import javax.annotation.Nonnull
 
@@ -51,6 +70,21 @@ class BlazeSdkModule(private val context: ReactApplicationContext): ReactContext
             val event = SdkModuleJsEvent.AnalyticEventTriggered(eventData)
             sendJsEvent(event)
         }
+
+        override suspend fun playbackModificationHandler(request: BlazePlaybackModificationRequest): BlazePlaybackModificationResponse {
+            val fallbackResponse = request.response()
+            val asyncBridge = context.blazeAsyncBridge ?: return fallbackResponse
+
+            return try {
+                asyncBridge.callJSMethod(
+                    name = PLAYBACK_MODIFICATION_METHOD_NAME,
+                    params = request,
+                )
+            } catch (e: Exception) {
+                Log.d(TAG, "Error playbackModificationHandler: ${e.message}")
+                fallbackResponse
+            }
+        }
     }
 
     private val playerEntryPointDelegate = object : BlazePlayerEntryPointDelegate {
@@ -117,6 +151,60 @@ class BlazeSdkModule(private val context: ReactApplicationContext): ReactContext
                 Log.e(TAG, "onPlayerEventTriggered: Exception - $e")
             }
         }
+
+        override fun onTriggerCustomActionButton(
+            playerType: BlazePlayerType,
+            sourceId: String?,
+            customParams: BlazePlayerCustomActionButtonParams
+        ) {
+            val event = SdkModuleJsEvent.TriggerCustomActionButton(playerType, sourceId, customParams)
+            sendJsEvent(event)
+        }
+
+        override fun onReadStatusChanged(
+            playerType: BlazePlayerType,
+            sourceId: String?,
+            dataSourceStringRepresentation: String,
+            isEntireContentRead: Boolean,
+            itemReadStatus: Map<String, Boolean>
+        ) {
+            val event = SdkModuleJsEvent.ReadStatusChanged(playerType, sourceId, dataSourceStringRepresentation, isEntireContentRead, itemReadStatus)
+            sendJsEvent(event)
+        }
+    }
+
+    private val followEntitiesDelegate = object : BlazeFollowEntitiesDelegate {
+        override fun onFollowEntityClicked(followEntityParams: BlazeFollowEntityClickedParams) {
+            val event = SdkModuleJsEvent.FollowEntityClicked(
+                playerType = followEntityParams.playerType,
+                sourceId = followEntityParams.sourceId,
+                newFollowingState = followEntityParams.newFollowingState,
+                followEntityId = followEntityParams.followEntity.entityId
+            )
+            sendJsEvent(event)
+        }
+    }
+
+    private val castingDelegate = object : BlazeCastingDelegate {
+        override fun onCastingStateChanged(
+            playerType: BlazePlayerType,
+            sourceId: String?,
+            newState: BlazeCastingState
+        ) {
+            val event = SdkModuleJsEvent.CastingStateChanged(playerType, sourceId, newState)
+            sendJsEvent(event)
+        }
+    }
+
+    private val pipDelegate = object : BlazePipDelegate {
+        override fun onPipStateChanged(
+            playerType: BlazePlayerType,
+            sourceId: String?,
+            newState: BlazePipState
+        ) {
+            val event = SdkModuleJsEvent.PiPStateChanged(playerType, sourceId, newState)
+            sendJsEvent(event)
+        }
     }
 
     init {
@@ -149,6 +237,10 @@ class BlazeSdkModule(private val context: ReactApplicationContext): ReactContext
                 playerEntryPointDelegate = playerEntryPointDelegate,
             )
 
+            BlazeSDK.followEntitiesManager.delegate = followEntitiesDelegate
+            BlazeSDK.castingManager.delegate = castingDelegate
+            BlazeSDK.pipManager.delegate = pipDelegate
+
             val reactStoryPlayerStyle = options.getMap(KEY_INIT_DEFAULT_STORY_PLAYER_STYLE)
             val reactMomentPlayerStyle = options.getMap(KEY_INIT_DEFAULT_MOMENT_PLAYER_STYLE)
             val reactVideosPlayerStyle = options.getMap(KEY_INIT_DEFAULT_VIDEO_PLAYER_STYLE)
@@ -222,6 +314,7 @@ class BlazeSdkModule(private val context: ReactApplicationContext): ReactContext
                 return
             }
 
+            val entryContentId = options.getString(KEY_ENTRY_POINT_CONTENT_ID)
             val playerStyle = options.getMap(KEY_ENTRY_POINT_PLAYER_THEME)
                 .extractStoriesPlayerStyle(context)
             val triggerSource = options.getString("triggerSource")?.asEntryPointTriggerSource
@@ -229,6 +322,7 @@ class BlazeSdkModule(private val context: ReactApplicationContext): ReactContext
             val shouldOrderContentByReadStatus = options.getBooleanOrNull("shouldOrderContentByReadStatus") ?: true
             BlazeSDK.playStories(
                 dataSource = dataSource,
+                entryContentId = entryContentId,
                 storyPlayerStyle = playerStyle,
                 triggerSource = triggerSource,
                 shouldOrderContentByReadStatus = shouldOrderContentByReadStatus
@@ -248,7 +342,8 @@ class BlazeSdkModule(private val context: ReactApplicationContext): ReactContext
                 promise.rejectWith("Error parsing data source for prepareStories")
                 return
             }
-            BlazeSDK.prepareStories(dataSource) { result ->
+            val entryContentId = options.getString(KEY_ENTRY_POINT_CONTENT_ID)
+            BlazeSDK.prepareStories(dataSource = dataSource, entryContentId = entryContentId) { result ->
                 promise.handleResult(result)
             }
         } catch (e: Exception) {
@@ -291,6 +386,7 @@ class BlazeSdkModule(private val context: ReactApplicationContext): ReactContext
                 return
             }
 
+            val entryContentId = options.getString(KEY_ENTRY_POINT_CONTENT_ID)
             val playerStyle = options.getMap(KEY_ENTRY_POINT_PLAYER_THEME)
                 .extractMomentsPlayerStyle(context)
             val triggerSource = options.getString("triggerSource")?.asEntryPointTriggerSource
@@ -298,6 +394,7 @@ class BlazeSdkModule(private val context: ReactApplicationContext): ReactContext
             val shouldOrderContentByReadStatus = options.getBooleanOrNull("shouldOrderContentByReadStatus") ?: true
             BlazeSDK.playMoments(
                 dataSource = dataSource,
+                entryContentId = entryContentId,
                 momentsPlayerStyle = playerStyle,
                 triggerSource = triggerSource,
                 shouldOrderContentByReadStatus = shouldOrderContentByReadStatus
@@ -317,7 +414,37 @@ class BlazeSdkModule(private val context: ReactApplicationContext): ReactContext
                 promise.rejectWith("Error parsing data source for prepareMoments")
                 return
             }
-            BlazeSDK.prepareMoments(dataSource) { result ->
+            val entryContentId = options.getString(KEY_ENTRY_POINT_CONTENT_ID)
+            BlazeSDK.prepareMoments(dataSource = dataSource, entryContentId = entryContentId) { result ->
+                promise.handleResult(result)
+            }
+        } catch (e: Exception) {
+            promise.rejectWith(e.toString())
+        }
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    fun appendMomentsToPlayer(options: ReadableMap, promise: Promise) {
+        try {
+            val sourceId = options.getString(KEY_ENTRY_POINT_SOURCE_ID) ?: run {
+                promise.rejectWith("Missing sourceId in appendMomentsToPlayer options")
+                return
+            }
+    
+            val dataSource = options.getMap(KEY_ENTRY_POINT_DATA_SOURCE)?.extractDataSource() ?: run {
+                promise.rejectWith("Error parsing data source for appendMomentsToPlayer")
+                return
+            }
+    
+            val shouldOrderContentByReadStatus =
+                options.getBooleanOrNull("shouldOrderContentByReadStatus") ?: false
+    
+            BlazeSDK.appendMomentsToPlayer(
+                sourceId = sourceId,
+                dataSourceType = dataSource,
+                shouldOrderContentByReadStatus = shouldOrderContentByReadStatus
+            ) { result ->
                 promise.handleResult(result)
             }
         } catch (e: Exception) {
@@ -338,10 +465,14 @@ class BlazeSdkModule(private val context: ReactApplicationContext): ReactContext
                 .extractVideosPlayerStyle(context)
             val triggerSource = options.getString("triggerSource")?.asEntryPointTriggerSource
                 ?: BlazeEntryPointTriggerSource.ENTRYPOINT
+            val playbackConfiguration = options.getMap(KEY_ENTRY_POINT_PLAYBACK_CONFIGURATION)
+                .extractVideosPlaybackConfiguration()
+                ?: BlazeSDK.getDefaultVideosPlaybackConfiguration()
             BlazeSDK.playVideo(
                 videoId = videoId,
                 videosPlayerStyle = playerStyle,
-                triggerSource = triggerSource
+                triggerSource = triggerSource,
+                playbackConfiguration = playbackConfiguration
                 ) { result ->
                 promise.handleResult(result)
             }
@@ -359,16 +490,22 @@ class BlazeSdkModule(private val context: ReactApplicationContext): ReactContext
                 return
             }
 
+            val entryContentId = options.getString(KEY_ENTRY_POINT_CONTENT_ID)
             val playerStyle = options.getMap(KEY_ENTRY_POINT_PLAYER_THEME)
                 .extractVideosPlayerStyle(context)
             val triggerSource = options.getString("triggerSource")?.asEntryPointTriggerSource
                 ?: BlazeEntryPointTriggerSource.ENTRYPOINT
             val shouldOrderContentByReadStatus = options.getBooleanOrNull("shouldOrderContentByReadStatus") ?: true
+            val playbackConfiguration = options.getMap(KEY_ENTRY_POINT_PLAYBACK_CONFIGURATION)
+                .extractVideosPlaybackConfiguration()
+                ?: BlazeSDK.getDefaultVideosPlaybackConfiguration()
             BlazeSDK.playVideos(
                 dataSource = dataSource,
+                entryContentId = entryContentId,
                 videosPlayerStyle = playerStyle,
                 triggerSource = triggerSource,
-                shouldOrderContentByReadStatus = shouldOrderContentByReadStatus
+                shouldOrderContentByReadStatus = shouldOrderContentByReadStatus,
+                playbackConfiguration = playbackConfiguration
             ) { result ->
                 promise.handleResult(result)
             }
@@ -385,7 +522,8 @@ class BlazeSdkModule(private val context: ReactApplicationContext): ReactContext
                 promise.rejectWith("Error parsing data source for prepareVideos")
                 return
             }
-            BlazeSDK.prepareVideos(dataSource) { result ->
+            val entryContentId = options.getString(KEY_ENTRY_POINT_CONTENT_ID)
+            BlazeSDK.prepareVideos(dataSource = dataSource, entryContentId = entryContentId) { result ->
                 promise.handleResult(result)
             }
         } catch (e: Exception) {
@@ -393,6 +531,82 @@ class BlazeSdkModule(private val context: ReactApplicationContext): ReactContext
         }
     }
 
+    @ReactMethod
+    @DoNotStrip
+    fun setDefaultVideosPlaybackConfiguration(config: ReadableMap, promise: Promise) {
+        try {
+            val playbackConfig = (config as ReadableMap?).extractVideosPlaybackConfiguration()
+                ?: run {
+                    promise.rejectWith("Invalid playback configuration")
+                    return
+                }
+            BlazeSDK.setDefaultVideosPlaybackConfiguration(playbackConfig)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.rejectWith(e.toString())
+        }
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    fun getDefaultVideosPlaybackConfiguration(promise: Promise) {
+        try {
+            val config = BlazeSDK.getDefaultVideosPlaybackConfiguration()
+            val result = Arguments.createMap().apply {
+                putBoolean("multiAspectRatio", config.multiAspectRatio)
+                putBoolean("shouldOpenInLandscape", config.shouldOpenOnLandscape)
+                putMap("pipConfiguration", Arguments.createMap().apply {
+                    putBoolean("enterPipOnAppBackground", config.pip.enterPipOnAppBackground)
+                })
+            }
+            promise.resolve(result)
+        } catch (e: Exception) {
+            promise.rejectWith(e.toString())
+        }
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    fun setDefaultMomentsPlaybackConfiguration(config: ReadableMap, promise: Promise) {
+        try {
+            val playbackConfig = (config as ReadableMap?).extractMomentsPlaybackConfiguration()
+                ?: run {
+                    promise.rejectWith("Invalid moments playback configuration")
+                    return
+                }
+            BlazeSDK.setDefaultMomentsPlaybackConfiguration(playbackConfig)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.rejectWith(e.toString())
+        }
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    fun getDefaultMomentsPlaybackConfiguration(promise: Promise) {
+        try {
+            val config = BlazeSDK.getDefaultMomentsPlaybackConfiguration()
+            val result = Arguments.createMap().apply {
+                val loopBehavior = Arguments.createMap().apply {
+                    when (config.loopBehavior) {
+                        is BlazeMomentsLoopBehavior.InfiniteLoop -> {
+                            putString("type", "infiniteLoop")
+                        }
+                        is BlazeMomentsLoopBehavior.LoopAndAdvance -> {
+                            putString("type", "loopAndAdvance")
+                            putInt("numberOfPlays",
+                                (config.loopBehavior as BlazeMomentsLoopBehavior.LoopAndAdvance).numberOfPlays)
+                        }
+                    }
+                }
+                putMap("loopBehavior", loopBehavior)
+            }
+            promise.resolve(result)
+        } catch (e: Exception) {
+            promise.rejectWith(e.toString())
+        }
+    }
+
     @ReactMethod
     @DoNotStrip
     fun dismissPlayer(promise: Promise) {
@@ -421,6 +635,13 @@ class BlazeSdkModule(private val context: ReactApplicationContext): ReactContext
         promise.resolve(doNotTrack)
     }
 
+    @ReactMethod
+    @DoNotStrip
+    fun setDisableAnalytics(disableAnalytics: Boolean, promise: Promise) {
+        BlazeSDK.disableAnalytics = disableAnalytics
+        promise.resolve(disableAnalytics)
+    }
+
     @ReactMethod
     @DoNotStrip
     fun handleUniversalLink(link: String, promise: Promise) {
@@ -484,6 +705,97 @@ class BlazeSdkModule(private val context: ReactApplicationContext): ReactContext
         }
     }
 
+    @ReactMethod
+    @DoNotStrip
+    fun setFollowedEntities(entityIds: ReadableArray, promise: Promise) {
+        try {
+            val entities = (0 until entityIds.size()).mapNotNull { entityIds.getString(it)?.let { id -> BlazeFollowEntity(id) } }.toSet()
+            BlazeSDK.followEntitiesManager.setFollowedEntities(entities)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.rejectWith(e.toString())
+        }
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    fun insertFollowedEntities(entityIds: ReadableArray, promise: Promise) {
+        try {
+            val entities = (0 until entityIds.size()).mapNotNull { entityIds.getString(it)?.let { id -> BlazeFollowEntity(id) } }.toSet()
+            BlazeSDK.followEntitiesManager.insertFollowedEntities(entities)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.rejectWith(e.toString())
+        }
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    fun removeFollowedEntities(entityIds: ReadableArray, promise: Promise) {
+        try {
+            val entities = (0 until entityIds.size()).mapNotNull { entityIds.getString(it)?.let { id -> BlazeFollowEntity(id) } }.toSet()
+            BlazeSDK.followEntitiesManager.removeFollowedEntities(entities)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.rejectWith(e.toString())
+        }
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    fun getFollowedEntities(promise: Promise) {
+        try {
+            val entities = BlazeSDK.followEntitiesManager.getFollowedEntities()
+            val ids = Arguments.createArray().apply {
+                entities.forEach { pushString(it.entityId) }
+            }
+            promise.resolve(ids)
+        } catch (e: Exception) {
+            promise.rejectWith(e.toString())
+        }
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    fun setPreferredLanguage(language: String?, promise: Promise) {
+        BlazeSDK.setPreferredLanguage(language)
+        promise.resolve(null)
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    fun showSearchScreen(options: ReadableMap, promise: Promise) {
+        val dataSourceType = options.getMap("suggestionsDataSource")?.extractDataSource()
+        if (dataSourceType == null) {
+            promise.rejectWith("suggestionsDataSource is required on Android")
+            return
+        }
+        val searchParams = BlazeSearchScreenParams(suggestionsDataSource = dataSourceType)
+        BlazeSDK.screens.showSearchScreen(searchParams = searchParams) { result ->
+            promise.handleResult(result)
+        }
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    fun stopActiveCastingSession(promise: Promise) {
+        BlazeSDK.castingManager.stopActiveCastingSession()
+        promise.resolve(null)
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    fun stopActivePiPSession(promise: Promise) {
+        BlazeSDK.pipManager.stopActivePiPSession()
+        promise.resolve(null)
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    fun isPiPActive(promise: Promise) {
+        promise.resolve(BlazeSDK.pipManager.isActive)
+    }
+
     companion object {
         const val NAME = "RTNBlazeSdk"
 
@@ -504,7 +816,10 @@ class BlazeSdkModule(private val context: ReactApplicationContext): ReactContext
         const val KEY_VIDEO_OPT_VIDEO_ID = "videoId"
         const val KEY_ENTRY_POINT_DATA_SOURCE = "dataSource"
         const val KEY_ENTRY_POINT_PLAYER_THEME = "playerStyle"
-
+        const val KEY_ENTRY_POINT_SOURCE_ID = "sourceId"
+        const val KEY_ENTRY_POINT_CONTENT_ID = "entryContentId"
+        const val KEY_ENTRY_POINT_PLAYBACK_CONFIGURATION = "playbackConfiguration"
+        private const val PLAYBACK_MODIFICATION_METHOD_NAME = "Blaze.GlobalDelegate.playbackModificationHandler"
     }
 
 }

package/android/src/main/java/com/blaze/rtnblazesdk/base/BaseWidgetView.kt

@@ -26,10 +26,12 @@ import com.blaze.rtnblazesdk.events.WidgetDataLoadCompletedEvent
 import com.blaze.rtnblazesdk.events.WidgetDataLoadStartedEvent
 import com.blaze.rtnblazesdk.events.WidgetHeightChangedEvent
 import com.blaze.rtnblazesdk.events.WidgetItemClickedEvent
+import com.blaze.rtnblazesdk.events.WidgetCustomActionButtonEvent
 import com.blaze.rtnblazesdk.events.WidgetOnPlayerEventTriggered
 import com.blaze.rtnblazesdk.events.WidgetOnTriggerPlayerBodyTextLinkEvent
 import com.blaze.rtnblazesdk.events.WidgetPlayerDidAppearEvent
 import com.blaze.rtnblazesdk.events.WidgetPlayerDismissedEvent
+import com.blaze.blazesdk.style.shared.models.BlazePlayerCustomActionButtonParams
 import com.blaze.rtnblazesdk.utils.extractCachingLevel
 import com.blaze.rtnblazesdk.utils.extractDataSource
 import com.blaze.rtnblazesdk.utils.getBooleanOrNull
@@ -61,6 +63,7 @@ abstract class BaseWidgetView @JvmOverloads constructor(
     var reactWidgetLayoutStyleMap: ReadableMap? = null
     var reactWidgetPlayerStyleMap: ReadableMap? = null
     var nativeWidgetLayout: BlazeWidgetLayout? = null
+    var reactWidgetPlaybackConfigurationMap: ReadableMap? = null
 
     val cachingLevel: BlazeCachingLevel
         get() = reactCachingLevel?.extractCachingLevel() ?: BlazeSdkModuleRepo.cachingLevel ?: BlazeCachingLevel.DEFAULT
@@ -182,6 +185,22 @@ abstract class BaseWidgetView @JvmOverloads constructor(
                     )
                 )
             }
+
+            override fun onTriggerCustomActionButton(
+                playerType: BlazePlayerType,
+                sourceId: String?,
+                customParams: BlazePlayerCustomActionButtonParams
+            ) {
+                dispatchEvent(
+                    WidgetCustomActionButtonEvent(
+                        UIManagerHelper.getSurfaceId(context),
+                        id,
+                        playerType = playerType,
+                        sourceId = sourceId,
+                        customParams = customParams
+                    )
+                )
+            }
         }
 
     abstract fun callInitWidget(dataSource: BlazeDataSourceType)

package/android/src/main/java/com/blaze/rtnblazesdk/base/BlazeWidgetViewManager.kt

@@ -2,6 +2,7 @@ package com.blaze.rtnblazesdk.base
 
 import androidx.annotation.Keep
 import com.blaze.rtnblazesdk.events.WidgetCTAClickEvent
+import com.blaze.rtnblazesdk.events.WidgetCustomActionButtonEvent
 import com.blaze.rtnblazesdk.events.WidgetDataLoadCompletedEvent
 import com.blaze.rtnblazesdk.events.WidgetDataLoadStartedEvent
 import com.blaze.rtnblazesdk.events.WidgetHeightChangedEvent
@@ -42,6 +43,7 @@ abstract class BlazeWidgetViewManager<TWidget : BaseWidgetView>(
             WidgetCTAClickEvent.EVENT_NAME to mapOf(Pair(KEY_EVENT_REGISTRATION_NAME, "onTriggerCTAInternal")),
             WidgetOnTriggerPlayerBodyTextLinkEvent.EVENT_NAME to mapOf(Pair(KEY_EVENT_REGISTRATION_NAME, "onTriggerPlayerBodyTextLinkInternal")),
             WidgetOnPlayerEventTriggered.EVENT_NAME to mapOf(Pair(KEY_EVENT_REGISTRATION_NAME, "onPlayerEventTriggeredInternal")),
+            WidgetCustomActionButtonEvent.EVENT_NAME to mapOf(Pair(KEY_EVENT_REGISTRATION_NAME, "onTriggerCustomActionButtonInternal")),
             WidgetHeightChangedEvent.EVENT_NAME to mapOf(Pair(KEY_EVENT_REGISTRATION_NAME, "onHeightChangedInternal")),
         )
         return map
@@ -128,6 +130,12 @@ abstract class BlazeWidgetViewManager<TWidget : BaseWidgetView>(
         view.reactWidgetPlayerStyleMap = value
     }
 
+    @Keep
+    @ReactProp(name = "playbackConfiguration")
+    fun setPlaybackConfiguration(view: TWidget, value: ReadableMap?) {
+        view.reactWidgetPlaybackConfigurationMap = value
+    }
+
     //---------- Props for Grids ----------//
 
     @Keep