react-native-firework-sdk 2.17.5 → 2.18.0

package/android/gradle.properties

@@ -6,4 +6,4 @@ FireworkSDK_targetSdkVersion=33
 FireworkSDK_compileSdkVersion=33
 FireworkSDK_kotlinVersion=1.8.22
 FireworkSDK_fwPlayerLaunchMode=singleTask
-FireworkSDK_fwNativeVersion=6.24.4
+FireworkSDK_fwNativeVersion=6.26.0

package/android/src/main/java/com/fireworksdk/bridge/components/storyblock/StoryBlockContainerView.kt

@@ -2,10 +2,15 @@ package com.fireworksdk.bridge.components.storyblock
 
 import android.content.Context
 import android.util.AttributeSet
+import android.view.View
 import android.widget.FrameLayout
+import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentActivity
+import androidx.fragment.app.FragmentManager
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
 import com.fireworksdk.bridge.models.FWVideoFeedPropsModel
-import com.fireworksdk.bridge.utils.FWLogUtils
+import com.fireworksdk.bridge.utils.FWFragmentUtil
 
 /**
  * StoryBlockContainerView provides safe Fragment management with automatic lifecycle handling.
@@ -21,66 +26,364 @@ class StoryBlockContainerView(
 
     private var isFragmentAttached = false
     private var pendingFragment: StoryBlockFragment? = null
+    
+    private var retryCount = 0
+    private val maxRetryCount = 3
+    
+    private var totalRetryCount = 0
+    private val maxTotalRetryCount = 6
+
+    private var isCallbackRegistered = false
+    private val pendingRunnables = mutableSetOf<Runnable>()
+    private var lifecycleObserver: LifecycleEventObserver? = null
+    private var isLifecycleObserverRegistered = false
 
     constructor(context: Context) : this(context, null)
 
+    /**
+     * Post a delayed runnable and track it for cleanup
+     */
+    private fun postDelayedTracked(delayMillis: Long, action: () -> Unit) {
+        val runnable = object : Runnable {
+            override fun run() {
+                pendingRunnables.remove(this)
+                action()
+            }
+        }
+        pendingRunnables.add(runnable)
+        postDelayed(runnable, delayMillis)
+    }
+
+    /**
+     * Post a runnable and track it for cleanup
+     */
+    private fun postTracked(action: () -> Unit) {
+        val runnable = object : Runnable {
+            override fun run() {
+                pendingRunnables.remove(this)
+                action()
+            }
+        }
+        pendingRunnables.add(runnable)
+        post(runnable)
+    }
+
+    /**
+     * Remove all pending callbacks to prevent memory leaks
+     */
+    private fun removeAllCallbacks() {
+        if (pendingRunnables.isNotEmpty()) {
+            val runnablesToRemove = pendingRunnables.toList()
+            runnablesToRemove.forEach { runnable ->
+                removeCallbacks(runnable)
+            }
+            pendingRunnables.clear()
+        }
+    }
+
+    /**
+     * Check if the given fragment is our StoryBlockFragment
+     * Uses multiple criteria: reference equality, tag matching, and type check
+     */
+    private fun isOurFragment(f: Fragment): Boolean {
+        if (f == storyBlockFragment) return true
+        if (f.tag == id.toString() && f is StoryBlockFragment) return true
+        return false
+    }
+    
+    /**
+     * Check if fragment can be attached to this container
+     * Returns true when fragment is not attached and this view is attached to window
+     */
+    private fun canAttachFragment(fragment: StoryBlockFragment): Boolean {
+        return !isFragmentAttached && !fragment.isAdded && isAttachedToWindow
+    }
+    
+    /**
+     * Check if fragment is already attached
+     * Opposite of canAttachFragment()
+     */
+    private fun isFragmentAlreadyAttached(fragment: StoryBlockFragment): Boolean {
+        return isFragmentAttached || fragment.isAdded
+    }
+
+    private fun isActivityFinished(activity: FragmentActivity): Boolean{
+        return activity.isFinishing || activity.isDestroyed
+    }
+
+    /**
+     * Fragment lifecycle callbacks to monitor fragment attachment state
+     */
+    private val fragmentLifecycleCallbacks = object : FragmentManager.FragmentLifecycleCallbacks() {
+        override fun onFragmentAttached(fm: FragmentManager, f: Fragment, context: Context) {
+            if (isOurFragment(f) && f is StoryBlockFragment) {
+                isFragmentAttached = true
+                retryCount = 0
+                totalRetryCount = 0
+                storyBlockFragment = f
+            }
+        }
+
+        override fun onFragmentDetached(fm: FragmentManager, f: Fragment) {
+            if (isOurFragment(f)) {
+                isFragmentAttached = false
+            }
+        }
+    }
+
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
-        // Try to attach pending fragment when view is attached
+        // Try to attach pending fragment when view is attached to window
         pendingFragment?.let { fragment ->
-            attachFragmentSafely(fragment)
+            val savedPendingFragment = fragment
             pendingFragment = null
+            
+            try {
+                attachFragmentSafely(savedPendingFragment)
+            } catch (_: Exception) {
+                if (pendingFragment == null) {
+                    if (!isFragmentAttached) {
+                        pendingFragment = savedPendingFragment
+                    }
+                }
+            }
         }
     }
 
     override fun onDetachedFromWindow() {
         super.onDetachedFromWindow()
-        // Fragment will be automatically detached by FragmentManager
+        
+        // Clean up all pending callbacks
+        removeAllCallbacks()
+        
+        // Unregister lifecycle observer
+        (context as? FragmentActivity)?.let { activity ->
+            unregisterLifecycleObserver(activity)
+        }
+        
+        // Unregister fragment lifecycle callbacks
+        if (isCallbackRegistered) {
+            (context as? FragmentActivity)?.supportFragmentManager?.let { fm ->
+                fm.unregisterFragmentLifecycleCallbacks(fragmentLifecycleCallbacks)
+                isCallbackRegistered = false
+            }
+        }
+        
+        // Clear all references to prevent memory leaks
+        // pendingFragment = null
+        // storyBlockFragment = null
         isFragmentAttached = false
+        retryCount = 0
+        totalRetryCount = 0
+    }
+
+    /**
+     * Verify if this view's ID can be found in the Activity's view hierarchy
+     */
+    private fun isViewInActivityHierarchy(activity: FragmentActivity): Boolean {
+        return try {
+            val contentView = activity.findViewById<View>(android.R.id.content)
+            val foundView = contentView?.findViewById<View>(id)
+            foundView === this
+        } catch (_: Exception) {
+            false
+        }
+    }
+
+    /**
+     * Check if it's safe to execute Fragment transactions
+     * Only returns true when Activity is RESUMED and state is not saved
+     */
+    private fun isSafeToCommit(activity: FragmentActivity): Boolean {
+        val currentState = activity.lifecycle.currentState
+        val isStateSaved = activity.supportFragmentManager.isStateSaved
+        return currentState.isAtLeast(Lifecycle.State.RESUMED) && !isStateSaved
     }
 
     /**
-     * Safely attach fragment to this container
+     * Safely attach fragment to this container with retry mechanism
+     * - Checks total retry limit (defensive programming)
+     * - Validates Activity and View state
+     * - Uses exponential backoff for retries
+     * - Defers to lifecycle observer if Activity is not RESUMED
      */
     fun attachFragmentSafely(fragment: StoryBlockFragment) {
-        if (isFragmentAttached || fragment.isAdded) {
+        // Defensive programming: absolute limit on total retry attempts
+        if (totalRetryCount >= maxTotalRetryCount) {
             return
         }
-
-        val activity = context as? FragmentActivity ?: run {
-            FWLogUtils.e { "Context is not FragmentActivity, cannot attach fragment" }
+        
+        if (isFragmentAlreadyAttached(fragment)) {
             return
         }
         
-        if (activity.isFinishing || activity.isDestroyed) {
-            FWLogUtils.w { "Activity is finishing or destroyed, cannot attach fragment" }
+        // Increment total retry counter
+        totalRetryCount++
+
+        val activity = context as? FragmentActivity ?: return
+        
+        if (isActivityFinished(activity)) {
             return
         }
 
-        try {
-            val fragmentManager = activity.supportFragmentManager
-            fragmentManager.beginTransaction()
-                .replace(id, fragment, id.toString())
-                .commitAllowingStateLoss()
+        // Ensure View has a valid ID
+        if (id == NO_ID) {
+            pendingFragment = fragment
+            return
+        }
+
+        // Ensure View is attached to window and has a parent
+        if (!isAttachedToWindow || parent == null) {
+            pendingFragment = fragment
+            return
+        }
+
+        // Check if view is in activity hierarchy before attempting fragment transaction
+        if (!isViewInActivityHierarchy(activity)) {
+            if (retryCount >= maxRetryCount) {
+                return
+            }
+            
+            retryCount++
+            val delayMs = 50L * retryCount // Exponential backoff: 50ms, 100ms, 150ms
+            
+            postDelayedTracked(delayMs) {
+                if (totalRetryCount >= maxTotalRetryCount) {
+                    return@postDelayedTracked
+                }
+                
+                if (canAttachFragment(fragment)) {
+                    attachFragmentSafely(fragment)
+                }
+            }
+            return
+        }
+
+        val fm = activity.supportFragmentManager
+        
+        // Register lifecycle callbacks to monitor fragment attachment (only once)
+        if (!isCallbackRegistered) {
+            fm.registerFragmentLifecycleCallbacks(fragmentLifecycleCallbacks, false)
+            isCallbackRegistered = true
+        }
+
+        // Delay to ensure the view hierarchy is fully laid out
+        postTracked {
+            if (!canAttachFragment(fragment)) {
+                return@postTracked
+            }
             
-            // Delay state update to ensure transaction is committed
-            post {
-                isFragmentAttached = fragment.isAdded
-                if (isFragmentAttached) {
-                    FWLogUtils.d { "Fragment attached successfully to container $id" }
-                } else {
-                    FWLogUtils.w { "Fragment attachment may have failed, fragment.isAdded = false" }
+            // Double-check view is still in activity hierarchy (race condition prevention)
+            val currentActivity = context as? FragmentActivity ?: return@postTracked
+
+            if (!isViewInActivityHierarchy(currentActivity)) {
+                return@postTracked
+            }
+            
+            // Double-check activity state (race condition prevention)
+            if (isActivityFinished(currentActivity)) {
+                return@postTracked
+            }
+
+            try {
+                executeFragmentTransaction(currentActivity, fragment, fm)
+            } catch (_: IllegalArgumentException) {
+                handleFragmentTransactionException(fragment, fm)
+            } catch (_: IllegalStateException) {
+                handleIllegalStateException(fragment)
+            } catch (_: Exception) {
+                handleUnexpectedException(fragment, fm)
+            }
+        }
+    }
+    
+    /**
+     * Execute Fragment transaction with lifecycle-aware commit strategy
+     * Uses commitNow() only when Activity is RESUMED to avoid commitAllowingStateLoss()
+     */
+    private fun executeFragmentTransaction(
+        activity: FragmentActivity,
+        fragment: StoryBlockFragment,
+        fm: FragmentManager
+    ) {
+        if (isSafeToCommit(activity)) {
+            fm.beginTransaction()
+                .replace(id, fragment, id.toString())
+                .commitNow() // Synchronous execution, exceptions can be caught
+            retryCount = 0
+        } else {
+            // Defer transaction until Activity becomes RESUMED
+            throw IllegalStateException("Cannot commit: lifecycle not RESUMED or state saved")
+        }
+    }
+    
+    /**
+     * Handle IllegalArgumentException during fragment transaction
+     * Typically caused by "No view found for id" errors
+     */
+    private fun handleFragmentTransactionException(
+        fragment: StoryBlockFragment,
+        fm: FragmentManager
+    ) {
+        if (isCallbackRegistered) {
+            fm.unregisterFragmentLifecycleCallbacks(fragmentLifecycleCallbacks)
+            isCallbackRegistered = false
+        }
+        
+        if (retryCount < maxRetryCount) {
+            retryCount++
+            val delayMs = 100L * retryCount
+            postDelayedTracked(delayMs) {
+                if (totalRetryCount >= maxTotalRetryCount) {
+                    return@postDelayedTracked
+                }
+                
+                if (canAttachFragment(fragment)) {
+                    attachFragmentSafely(fragment)
                 }
             }
-        } catch (e: Exception) {
-            FWLogUtils.e { "Failed to attach fragment: ${e.message}" }
-            // Store fragment for later attachment
-            pendingFragment = fragment
+        } else {
+            retryCount = 0
+        }
+    }
+    
+    /**
+     * Handle IllegalStateException during fragment transaction
+     * Saves fragment as pending and registers lifecycle observer to retry when Activity becomes RESUMED
+     */
+    private fun handleIllegalStateException(
+        fragment: StoryBlockFragment,
+    ) {
+        val activity = (context as? FragmentActivity) ?: return
+        
+        pendingFragment = fragment
+        retryCount = 0
+        
+        if (!isLifecycleObserverRegistered) {
+            registerLifecycleObserver(activity)
+        }
+    }
+    
+    /**
+     * Handle unexpected exceptions during fragment transaction
+     * Stores fragment for later attachment
+     */
+    private fun handleUnexpectedException(
+        fragment: StoryBlockFragment,
+        fm: FragmentManager
+    ) {
+        if (isCallbackRegistered) {
+            fm.unregisterFragmentLifecycleCallbacks(fragmentLifecycleCallbacks)
+            isCallbackRegistered = false
         }
+        
+        pendingFragment = fragment
     }
 
     /**
      * Set fragment to be attached when container is ready
+     * If view is already attached to window, attempts immediate attachment
+     * Otherwise, defers attachment until onAttachedToWindow()
      */
     fun setFragment(fragment: StoryBlockFragment) {
         storyBlockFragment = fragment
@@ -90,14 +393,117 @@ class StoryBlockContainerView(
             pendingFragment = fragment
         }
     }
-
+    
+    /**
+     * Create lifecycle observer to monitor Activity state changes
+     * Automatically retries fragment attachment when Activity becomes RESUMED
+     */
+    private fun createLifecycleObserver(activity: FragmentActivity): LifecycleEventObserver {
+        return LifecycleEventObserver { _, event ->
+            when (event) {
+                Lifecycle.Event.ON_RESUME -> {
+                    pendingFragment?.let { fragment ->
+                        if (canAttachFragment(fragment)) {
+                            // Reset retry counters when Activity reaches RESUMED state
+                            // This is the ideal time to attach fragments, so we give it a fresh chance
+                            // even if previous attempts failed during non-ideal lifecycle states
+                            if (totalRetryCount >= maxTotalRetryCount) {
+                                totalRetryCount = 0
+                                retryCount = 0
+                            }
+                            
+                            try {
+                                attachFragmentSafely(fragment)
+                            } catch (_: Exception) {
+                                // Ignore
+                            }
+                        } else {
+                            if (isFragmentAlreadyAttached(fragment)) {
+                                pendingFragment = null
+                            }
+                        }
+                    }
+                }
+                
+                Lifecycle.Event.ON_DESTROY -> {
+                    unregisterLifecycleObserver(activity)
+                    pendingFragment = null
+                }
+                
+                else -> {}
+            }
+        }
+    }
+    
+    /**
+     * Register lifecycle observer to automatically retry when Activity becomes RESUMED
+     */
+    private fun registerLifecycleObserver(activity: FragmentActivity) {
+        if (isLifecycleObserverRegistered) {
+            return
+        }
+        
+        val observer = createLifecycleObserver(activity)
+        activity.lifecycle.addObserver(observer)
+        
+        lifecycleObserver = observer
+        isLifecycleObserverRegistered = true
+    }
+    
     /**
-     * Clean up resources when the view is destroyed
+     * Unregister lifecycle observer to prevent memory leaks
      */
+    private fun unregisterLifecycleObserver(activity: FragmentActivity) {
+        if (!isLifecycleObserverRegistered) {
+            return
+        }
+        
+        lifecycleObserver?.let { observer ->
+            try {
+                if (activity.lifecycle.currentState != Lifecycle.State.DESTROYED) {
+                    activity.lifecycle.removeObserver(observer)
+                }
+            } catch (_: Exception) {
+                // Ignore
+            }
+        }
+        
+        lifecycleObserver = null
+        isLifecycleObserverRegistered = false
+    }
+
     override fun destroy() {
-        // Fragment will be automatically cleaned up by FragmentManager
+        removeAllCallbacks()
+        
+        // Capture fragment reference before clearing to prevent race condition
+        // This ensures the fragment can be properly cleaned up even if dispose() is called concurrently
+        val fragmentToCleanup = storyBlockFragment
+        
+        (context as? FragmentActivity)?.let { activity ->
+            unregisterLifecycleObserver(activity)
+            
+            // Clean up fragment before clearing the reference
+            if (fragmentToCleanup != null) {
+                try {
+                    fragmentToCleanup.removeIvsPlayerView()
+                    FWFragmentUtil.removeFragment(activity, fragmentToCleanup)
+                } catch (e: Exception) {
+                    // Log but don't crash
+                }
+            }
+        }
+        
+        if (isCallbackRegistered) {
+            (context as? FragmentActivity)?.supportFragmentManager?.let { fm ->
+                fm.unregisterFragmentLifecycleCallbacks(fragmentLifecycleCallbacks)
+                isCallbackRegistered = false
+            }
+        }
+        
         isFragmentAttached = false
         pendingFragment = null
         storyBlockFragment = null
+        retryCount = 0
+        totalRetryCount = 0
     }
 }

package/android/src/main/java/com/fireworksdk/bridge/models/FWPlayerButtonConfigurationDeserializer.kt

@@ -6,6 +6,7 @@ object FWPlayerButtonConfigurationDeserializer {
 
   private const val VIDEO_DETAIL_BUTTON_KEY = "videoDetailButton"
   private const val CLOSE_BUTTON_KEY = "closeButton"
+  private const val SHOULD_SHOW_CLOSE_BUTTON_WHEN_PIP_ENABLED_KEY = "shouldShowCloseButtonWhenPiPEnabled"
   private const val PIP_BUTTON_KEY = "pipButton"
   private const val MUTE_BUTTON_KEY = "muteButton"
   private const val UNMUTE_BUTTON_KEY = "unmuteButton"
@@ -17,6 +18,7 @@ object FWPlayerButtonConfigurationDeserializer {
 
     val videoDetailButtonJsonObject = responseJson.optJSONObject(VIDEO_DETAIL_BUTTON_KEY)
     val closeButtonJsonObject = responseJson.optJSONObject(CLOSE_BUTTON_KEY)
+    val shouldShowCloseButtonWhenPiPEnabled = responseJson.optBoolean(SHOULD_SHOW_CLOSE_BUTTON_WHEN_PIP_ENABLED_KEY, false)
     val pipButtonJsonObject = responseJson.optJSONObject(PIP_BUTTON_KEY)
     val muteButtonJsonObject = responseJson.optJSONObject(MUTE_BUTTON_KEY)
     val unmuteButtonJsonObject = responseJson.optJSONObject(UNMUTE_BUTTON_KEY)
@@ -26,6 +28,7 @@ object FWPlayerButtonConfigurationDeserializer {
     return FWPlayerButtonConfigurationModel(
       videoDetailButton = FWButtonInfoDeserializer.deserialize(videoDetailButtonJsonObject),
       closeButton = FWButtonInfoDeserializer.deserialize(closeButtonJsonObject),
+      shouldShowCloseButtonWhenPiPEnabled = shouldShowCloseButtonWhenPiPEnabled,
       pipButton = FWButtonInfoDeserializer.deserialize(pipButtonJsonObject),
       muteButton = FWButtonInfoDeserializer.deserialize(muteButtonJsonObject),
       unmuteButton = FWButtonInfoDeserializer.deserialize(unmuteButtonJsonObject),

package/android/src/main/java/com/fireworksdk/bridge/models/FWPlayerButtonConfigurationModel.kt

@@ -3,6 +3,7 @@ package com.fireworksdk.bridge.models
 data class FWPlayerButtonConfigurationModel(
   val videoDetailButton: FWButtonInfoModel? = null,
   val closeButton: FWButtonInfoModel? = null,
+  val shouldShowCloseButtonWhenPiPEnabled: Boolean? = null,
   val pipButton: FWButtonInfoModel? = null,
   val muteButton: FWButtonInfoModel? = null,
   val unmuteButton: FWButtonInfoModel? = null,

package/android/src/main/java/com/fireworksdk/bridge/models/FWPlayerButtonConfigurationSerializer.kt

@@ -6,6 +6,7 @@ object FWPlayerButtonConfigurationSerializer {
 
   private const val VIDEO_DETAIL_BUTTON_KEY = "videoDetailButton"
   private const val CLOSE_BUTTON_KEY = "closeButton"
+  private const val SHOULD_SHOW_CLOSE_BUTTON_WHEN_PIP_ENABLED_KEY = "shouldShowCloseButtonWhenPiPEnabled"
   private const val PIP_BUTTON_KEY = "pipButton"
   private const val MUTE_BUTTON_KEY = "muteButton"
   private const val UNMUTE_BUTTON_KEY = "unmuteButton"
@@ -17,6 +18,7 @@ object FWPlayerButtonConfigurationSerializer {
     val jsonObject = JSONObject()
     jsonObject.put(VIDEO_DETAIL_BUTTON_KEY, FWButtonInfoSerializer.serialize(model.videoDetailButton))
     jsonObject.put(CLOSE_BUTTON_KEY, FWButtonInfoSerializer.serialize(model.closeButton))
+    jsonObject.put(SHOULD_SHOW_CLOSE_BUTTON_WHEN_PIP_ENABLED_KEY, model.shouldShowCloseButtonWhenPiPEnabled)
     jsonObject.put(PIP_BUTTON_KEY, FWButtonInfoSerializer.serialize(model.pipButton))
     jsonObject.put(MUTE_BUTTON_KEY, FWButtonInfoSerializer.serialize(model.muteButton))
     jsonObject.put(UNMUTE_BUTTON_KEY, FWButtonInfoSerializer.serialize(model.unmuteButton))

package/android/src/main/java/com/fireworksdk/bridge/models/FWVideoPlayerConfigModel.kt

@@ -4,9 +4,12 @@ import com.fireworksdk.bridge.models.enums.FWCtaDelayType
 import com.fireworksdk.bridge.models.enums.FWPlayerStyle
 import com.fireworksdk.bridge.models.enums.FWVideoCompleteAction
 import com.fireworksdk.bridge.models.enums.FWVideoPlayerCTAWidth
+import com.fireworksdk.bridge.models.enums.FWVideoPlayerScrollDirection
 
 data class FWVideoPlayerConfigModel(
   val playerStyle: FWPlayerStyle? = null,
+  val scrollDirection: FWVideoPlayerScrollDirection? = null,
+  val enableScrollForVertical: Boolean? = null,
   val videoCompleteAction: FWVideoCompleteAction? = null,
   val showShareButton: Boolean? = null,
   val ctaButtonStyle: FWCtaButtonStyleModel? = null,

package/android/src/main/java/com/fireworksdk/bridge/models/FWVideoPlayerConfigModelDeserializer.kt

@@ -4,11 +4,14 @@ import com.fireworksdk.bridge.models.enums.FWCtaDelayType
 import com.fireworksdk.bridge.models.enums.FWPlayerStyle
 import com.fireworksdk.bridge.models.enums.FWVideoCompleteAction
 import com.fireworksdk.bridge.models.enums.FWVideoPlayerCTAWidth
+import com.fireworksdk.bridge.models.enums.FWVideoPlayerScrollDirection
 import org.json.JSONObject
 
 object FWVideoPlayerConfigModelDeserializer {
 
   private const val PLAYER_STYLE_KEY = "playerStyle"
+  private const val SCROLL_DIRECTION_KEY = "scrollDirection"
+  private const val ENABLE_SCROLL_FOR_VERTICAL_KEY = "enableScrollForVertical"
   private const val VIDEO_COMPLETE_ACTION_KEY = "videoCompleteAction"
   private const val SHOW_SHARE_BUTTON_KEY = "showShareButton"
   private const val CTA_BUTTON_STYLE_KEY = "ctaButtonStyle"
@@ -50,6 +53,8 @@ object FWVideoPlayerConfigModelDeserializer {
     responseJson ?: return null
 
     val playerStyle = if (responseJson.has(PLAYER_STYLE_KEY)) responseJson.optString(PLAYER_STYLE_KEY) else null
+    val scrollDirection = if (responseJson.has(SCROLL_DIRECTION_KEY)) responseJson.optString(SCROLL_DIRECTION_KEY) else null
+    val enableScrollForVertical = if (responseJson.has(ENABLE_SCROLL_FOR_VERTICAL_KEY)) responseJson.optBoolean(ENABLE_SCROLL_FOR_VERTICAL_KEY) else null
     val videoCompleteAction = if (responseJson.has(VIDEO_COMPLETE_ACTION_KEY)) responseJson.optString(VIDEO_COMPLETE_ACTION_KEY) else null
     val showShareButton = if (responseJson.has(SHOW_SHARE_BUTTON_KEY)) responseJson.optBoolean(SHOW_SHARE_BUTTON_KEY) else null
     val ctaButtonStyle = deserializeCtaButtonStyle(responseJson.optJSONObject(CTA_BUTTON_STYLE_KEY))
@@ -84,6 +89,8 @@ object FWVideoPlayerConfigModelDeserializer {
 
     return FWVideoPlayerConfigModel(
       playerStyle = if (!playerStyle.isNullOrBlank()) FWPlayerStyle.deserialize(playerStyle) else null,
+      scrollDirection = if (!scrollDirection.isNullOrBlank()) FWVideoPlayerScrollDirection.deserialize(scrollDirection) else null,
+      enableScrollForVertical = enableScrollForVertical,
       videoCompleteAction = if (!videoCompleteAction.isNullOrBlank()) FWVideoCompleteAction.deserialize(videoCompleteAction) else null,
       showShareButton = showShareButton,
       ctaButtonStyle = ctaButtonStyle,

package/android/src/main/java/com/fireworksdk/bridge/models/FWVideoPlayerConfigModelSerializer.kt

@@ -4,11 +4,14 @@ import com.fireworksdk.bridge.models.enums.FWCtaDelayType
 import com.fireworksdk.bridge.models.enums.FWPlayerStyle
 import com.fireworksdk.bridge.models.enums.FWVideoCompleteAction
 import com.fireworksdk.bridge.models.enums.FWVideoPlayerCTAWidth
+import com.fireworksdk.bridge.models.enums.FWVideoPlayerScrollDirection
 import org.json.JSONObject
 
 object FWVideoPlayerConfigModelSerializer {
 
   private const val PLAYER_STYLE_KEY = "playerStyle"
+  private const val SCROLL_DIRECTION_KEY = "scrollDirection"
+  private const val ENABLE_SCROLL_FOR_VERTICAL_KEY = "enableScrollForVertical"
   private const val VIDEO_COMPLETE_ACTION_KEY = "videoCompleteAction"
   private const val SHOW_SHARE_BUTTON_KEY = "showShareButton"
   private const val CTA_BUTTON_STYLE_KEY = "ctaButtonStyle"
@@ -55,6 +58,8 @@ object FWVideoPlayerConfigModelSerializer {
     model ?: return null
     val jsonObject = JSONObject()
     jsonObject.put(PLAYER_STYLE_KEY, FWPlayerStyle.serialize(model.playerStyle))
+    jsonObject.put(SCROLL_DIRECTION_KEY, FWVideoPlayerScrollDirection.serialize(model.scrollDirection))
+    jsonObject.put(ENABLE_SCROLL_FOR_VERTICAL_KEY, model.enableScrollForVertical)
     jsonObject.put(VIDEO_COMPLETE_ACTION_KEY, FWVideoCompleteAction.serialize(model.videoCompleteAction))
     jsonObject.put(SHOW_SHARE_BUTTON_KEY, model.showShareButton)
     jsonObject.put(CTA_BUTTON_STYLE_KEY, serializeCtaButtonStyle(model.ctaButtonStyle))

package/android/src/main/java/com/fireworksdk/bridge/models/enums/FWVideoPlayerScrollDirection.kt

@@ -0,0 +1,17 @@
+package com.fireworksdk.bridge.models.enums
+
+enum class FWVideoPlayerScrollDirection(val rawValue: String) {
+  Vertical("vertical"),
+  Horizontal("horizontal");
+
+  companion object {
+    fun deserialize(rawValue: String): FWVideoPlayerScrollDirection? {
+      return values().firstOrNull { it.rawValue == rawValue }
+    }
+
+    fun serialize(value: FWVideoPlayerScrollDirection?): String? {
+      return value?.rawValue
+    }
+  }
+}
+

package/android/src/main/java/com/fireworksdk/bridge/models/enums/FWVideoPlayerVersion.kt

@@ -0,0 +1,6 @@
+package com.fireworksdk.bridge.models.enums
+
+enum class FWVideoPlayerVersion(val rawValue: String) {
+  V1("v1"),
+  V2("v2"),
+}