react-native-firework-sdk 2.2.5 → 2.3.1

package/android/src/main/java/com/fireworksdk/bridge/reactnative/utils/FWEventUtils.kt

@@ -6,47 +6,17 @@ import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.facebook.react.uimanager.events.RCTEventEmitter
 import com.firework.common.product.Product
 import com.fireworksdk.bridge.models.*
-import com.fireworksdk.bridge.FWInitializationProvider
-import com.fireworksdk.bridge.reactnative.pages.FWContainerActivity
+import com.fireworksdk.bridge.models.enums.FWEventName
+import com.fireworksdk.bridge.models.enums.FWFeedViewEventName
+import com.fireworksdk.bridge.models.enums.FWSDKInitSubEventName
+import com.fireworksdk.bridge.models.enums.FWStoryBlockEventName
+import com.fireworksdk.bridge.models.enums.FWVideoShoppingEventName
 import com.fireworksdk.bridge.utils.FWDateUtils
-import com.fireworksdk.bridge.utils.FWGlobalDataUtil
 import com.fireworksdk.bridge.utils.FWLogUtils
 import java.util.*
 
 object FWEventUtils {
 
-  fun pushNativeContainer(reactContext: ReactContext, props: ReadableMap?, promise: Promise?) {
-    FWLogUtils.d { "FWNavigatorModule pushNativeContainer: $props" }
-    val activity = FWInitializationProvider.INSTANCE.resumedActivity
-
-    if (activity == null || FWGlobalDataUtil.appComponentName.isNullOrBlank()) {
-      promise?.resolve(false)
-      return
-    }
-
-    sendLogMessageEvent(reactContext, "[Android] Enter pushNativeContainer ${
-      FWDateUtils.getDateString(
-        Date()
-      )}")
-
-    UiThreadUtil.runOnUiThread {
-
-      sendLogMessageEvent(reactContext, "[Android] Before Starting container activity ${
-        FWDateUtils.getDateString(
-          Date()
-        )}")
-
-      activity.startActivity(FWContainerActivity.createIntent(activity, FWGlobalDataUtil.appComponentName, props?.toHashMap()))
-
-      sendLogMessageEvent(reactContext, "[Android] After Starting container activity ${
-        FWDateUtils.getDateString(
-          Date()
-        )}")
-    }
-
-    promise?.resolve(true)
-  }
-
   fun sendInitSuccessEvent(reactContext: ReactContext) {
     sendEvent(reactContext, FWEventName.SDKIni.rawValue, Arguments.createMap())
   }
@@ -105,25 +75,25 @@ object FWEventUtils {
     eventMap.putString("eventName", eventName)
 
     val contentMap = Arguments.createMap()
-    if (!info?.videoId.isNullOrBlank()) {
-      contentMap.putString("videoId", info?.videoId)
+    if (!info?.id.isNullOrBlank()) {
+      contentMap.putString("videoId", info?.id)
     }
     if (info?.duration != null) {
       contentMap.putDouble("duration", info.duration)
     }
-    if (info?.caption.isNullOrBlank()) {
+    if (!info?.caption.isNullOrBlank()) {
       contentMap.putString("caption", info?.caption)
     }
-    if (info?.badge.isNullOrBlank()) {
+    if (!info?.badge.isNullOrBlank() && !info?.badge.equals("null")) {
       contentMap.putString("badge", info?.badge)
     }
-    if (info?.width != null || info?.height != null) {
+    if (info?.playerWidth != null || info?.playerHeight != null) {
       val playerSizeMap = Arguments.createMap()
-      if (info.width != null) {
-        playerSizeMap.putInt("width", info.width)
+      if (info.playerWidth != null) {
+        playerSizeMap.putInt("width", info.playerWidth)
       }
-      if (info.height != null) {
-        playerSizeMap.putInt("height", info.height)
+      if (info.playerHeight != null) {
+        playerSizeMap.putInt("height", info.playerHeight)
       }
       contentMap.putMap("playerSize", playerSizeMap)
     }
@@ -133,6 +103,9 @@ object FWEventUtils {
     if (info?.progress != null) {
       contentMap.putDouble("progress", info.progress)
     }
+    if (!info?.actionUrl.isNullOrBlank()) {
+      contentMap.putString("ctaActionURL", info?.actionUrl)
+    }
     eventMap.putMap("info", contentMap)
 
     sendEvent(reactContext, FWEventName.VideoPlayback.rawValue, eventMap)

package/android/src/main/java/com/fireworksdk/bridge/utils/FWBundleUtils.kt

@@ -6,34 +6,58 @@ import android.os.Parcelable
 
 object FWBundleUtils {
 
+  @Suppress("UNCHECKED_CAST")
   fun mapToBundle(map: Map<String, Any?>?): Bundle? {
     if (map == null) {
       return null
     }
     val bundle = Bundle()
     for ((key, value) in map) {
-      if (value is Double) {
-        bundle.putDouble(key, value)
-      } else if (value is Int) {
-        bundle.putInt(key, value)
-      } else if (value is String) {
-        bundle.putString(key, value)
-      } else if (value is Boolean) {
-        bundle.putBoolean(key, value)
-      } else if (value is List<*>) {
-        val list = value as List<Any>
-        val first = list[0]
-        if (first == null || first is Double) {
-          bundle.putDoubleArray(key, listToDoubleArray(list))
-        } else if (first is Int) {
-          bundle.putIntArray(key, listToIntArray(list))
-        } else if (first is String) {
-          bundle.putStringArray(key, listToStringArray(list))
-        } else if (first is Map<*, *>) {
-          bundle.putParcelableArrayList(key, listToParcelableArrayList(list))
+      when (value) {
+        is Double -> {
+          bundle.putDouble(key, value)
         }
-      } else if (value is Map<*, *>) {
-        bundle.putBundle(key, mapToBundle(value as Map<String, Any>))
+
+        is Int -> {
+          bundle.putInt(key, value)
+        }
+
+        is String -> {
+          bundle.putString(key, value)
+        }
+
+        is Boolean -> {
+          bundle.putBoolean(key, value)
+        }
+
+        is List<*> -> {
+          val list = value as List<Any>
+          when (list[0]) {
+            is Double -> {
+              bundle.putDoubleArray(key, listToDoubleArray(list))
+            }
+
+            is Int -> {
+              bundle.putIntArray(key, listToIntArray(list))
+            }
+
+            is String -> {
+              bundle.putStringArray(key, listToStringArray(list))
+            }
+
+            is Map<*, *> -> {
+              bundle.putParcelableArrayList(key, listToParcelableArrayList(list))
+            }
+
+            else -> {}
+          }
+        }
+
+        is Map<*, *> -> {
+          bundle.putBundle(key, mapToBundle(value as Map<String, Any>))
+        }
+
+        else -> {}
       }
     }
     return bundle
@@ -72,6 +96,7 @@ object FWBundleUtils {
     return strings
   }
 
+  @Suppress("UNCHECKED_CAST")
   private fun listToParcelableArrayList(list: List<Any>?): ArrayList<Parcelable?>? {
     if (list == null) {
       return null

package/android/src/main/java/com/fireworksdk/bridge/utils/FWConfigUtil.kt

@@ -1,10 +1,13 @@
 package com.fireworksdk.bridge.utils
 
+import android.content.Context
 import android.graphics.Color
 import android.graphics.Typeface
+import android.graphics.drawable.GradientDrawable
 import com.firework.common.PlayerMode
 import com.firework.common.ad.AdBadgeOption
 import com.firework.common.ad.AdBadgeTextType
+import com.firework.common.ad.AdOption
 import com.firework.common.cta.CtaDelay
 import com.firework.common.cta.CtaDelayUnit
 import com.firework.common.feed.FeedLayout
@@ -12,14 +15,23 @@ import com.firework.common.feed.FeedResource
 import com.firework.common.feed.FeedTitlePosition
 import com.firework.viewoptions.*
 import com.fireworksdk.bridge.FWInitializationProvider
-import com.fireworksdk.bridge.constants.FWVideoPlayerConstant
 import com.fireworksdk.bridge.models.*
-import com.fireworksdk.bridge.reactnative.module.FireworkSDKModule
+import com.fireworksdk.bridge.models.enums.FWBadgeTextType
+import com.fireworksdk.bridge.models.enums.FWCtaDelayType
+import com.fireworksdk.bridge.models.enums.FWGradientDrawableOrientation
+import com.fireworksdk.bridge.models.enums.FWPlayerStyle
+import com.fireworksdk.bridge.models.enums.FWSystemTypeface
+import com.fireworksdk.bridge.models.enums.FWVideoCompleteAction
+import com.fireworksdk.bridge.models.enums.FWVideoFeedMode
+import com.fireworksdk.bridge.models.enums.FWVideoFeedSource
+import com.fireworksdk.bridge.models.enums.FWVideoFeedTitlePosition
+import com.fireworksdk.bridge.models.enums.FWVideoPlayerCTAWidth
 
 object FWConfigUtil {
 
-  fun generateViewOptionsBuilder(videoFeedPropsModel: FWVideoFeedPropsModel): ViewOptions.Builder {
-    val context = FWInitializationProvider.INSTANCE.resumedActivity ?: return ViewOptions.Builder()
+  fun generateViewOptionsBuilder(context: Context?, videoFeedPropsModel: FWVideoFeedPropsModel?): ViewOptions.Builder {
+    context ?: return ViewOptions.Builder()
+    videoFeedPropsModel ?: return ViewOptions.Builder()
 
     val layoutOptionBuilder = getDefaultLayoutOptionBuilder()
     val titleOptionBuilder = getDefaultTitleOptionBuilder()
@@ -27,32 +39,33 @@ object FWConfigUtil {
     val baseOptionBuilder = getDefaultBaseOptionBuilder()
     val adBadgeOptionBuilder = getDefaultAdBadgeOptionBuilder()
     val ctaOptionBuilder = getDefaultCtaOptionBuilder()
+    val adOptionBuilder = getDefaultAdOptionBuilder()
 
     when (videoFeedPropsModel.source) {
-      FWVideoFeedSource.Discover.rawValue -> {
+      FWVideoFeedSource.Discover -> {
         baseOptionBuilder.feedResource(FeedResource.Discovery)
       }
-      FWVideoFeedSource.Channel.rawValue -> {
+      FWVideoFeedSource.Channel -> {
         videoFeedPropsModel.channel?.let { channel ->
           baseOptionBuilder.feedResource(FeedResource.Channel(channel))
         }
       }
-      FWVideoFeedSource.Playlist.rawValue -> {
+      FWVideoFeedSource.Playlist -> {
         videoFeedPropsModel.channel?.let { channel ->
           videoFeedPropsModel.playlist?.let { playlist ->
             baseOptionBuilder.feedResource(FeedResource.Playlist(channel, playlist))
           }
         }
       }
-      FWVideoFeedSource.DynamicContent.rawValue -> {
+      FWVideoFeedSource.DynamicContent -> {
         videoFeedPropsModel.channel?.let { channel ->
           baseOptionBuilder.feedResource(FeedResource.DynamicContent(channel, videoFeedPropsModel.dynamicContentParameters?:hashMapOf()))
         }
       }
-      FWVideoFeedSource.PlaylistGroup.rawValue -> {
+      FWVideoFeedSource.PlaylistGroup -> {
 
       }
-      FWVideoFeedSource.HashtagPlaylist.rawValue -> {
+      FWVideoFeedSource.HashtagPlaylist -> {
         videoFeedPropsModel.channel?.let { channel ->
           if (!videoFeedPropsModel.hashtagFilterExpression.isNullOrBlank()) {
             baseOptionBuilder.feedResource(FeedResource.ChannelHashtag(channel, videoFeedPropsModel.hashtagFilterExpression))
@@ -65,13 +78,13 @@ object FWConfigUtil {
     }
 
     when (videoFeedPropsModel.mode) {
-      FWVideoFeedModel.Row.rawValue -> {
+      FWVideoFeedMode.Row -> {
         layoutOptionBuilder.feedLayout(FeedLayout.HORIZONTAL)
       }
-      FWVideoFeedModel.Column.rawValue -> {
+      FWVideoFeedMode.Column -> {
         layoutOptionBuilder.feedLayout(FeedLayout.VERTICAL)
       }
-      FWVideoFeedModel.Grid.rawValue -> {
+      FWVideoFeedMode.Grid -> {
         layoutOptionBuilder.feedLayout(FeedLayout.GRID)
       }
       else -> {}
@@ -83,62 +96,84 @@ object FWConfigUtil {
     }
 
     val cornerRadius = videoFeedPropsModel.videoFeedConfiguration?.cornerRadius
-    if (cornerRadius != null && cornerRadius > 0) {
+    if (cornerRadius != null && cornerRadius >= 0) {
       layoutOptionBuilder.roundedCorner(true)
         .roundedCornerRadius(FWCommonUtil.dpToPx(cornerRadius.toFloat(), context))
     }
 
     val title = videoFeedPropsModel.videoFeedConfiguration?.title
     if (title != null) {
-      val hidden = title.hidden
-      val textColor = title.textColor
-      val fontSize = title.fontSize
-      val fontInfo = title.fontInfo
-      if (hidden != null) {
-        titleOptionBuilder.showFeedTitle(!hidden)
+      val titleHidden = title.hidden
+      val titleTextColor = title.textColor
+      val titleFontSize = title.fontSize
+      val titleBackgroundColor = title.backgroundColor
+      val titleGradientDrawable = title.gradientDrawable
+      val typeface = getTypeface(context, title.fontInfo)
+      if (titleHidden != null) {
+        titleOptionBuilder.showFeedTitle(!titleHidden)
       }
-      if (!textColor.isNullOrBlank()) {
-        titleOptionBuilder.feedTitleTextColor(Color.parseColor(textColor))
+      if (!titleTextColor.isNullOrBlank()) {
+        titleOptionBuilder.feedTitleTextColor(Color.parseColor(titleTextColor))
       }
-      if (fontSize != null && fontSize > 0) {
-        titleOptionBuilder.feedTitleTextSize(FWCommonUtil.spToPx(fontSize.toFloat(), context))
+      if (titleFontSize != null && titleFontSize > 0) {
+        titleOptionBuilder.feedTitleTextSize(FWCommonUtil.spToPx(titleFontSize.toFloat(), context))
       }
-      fontInfo?.let { font ->
-        font.typefaceName?.let {
-          var typeface = Typeface.DEFAULT
-          if (font.isCustom == true) {
-            typeface = Typeface.createFromAsset(context.assets, it)
-          } else {
-            when (it) {
-              FWSystemTypeface.DefaultBold.rawValue -> {
-                typeface = Typeface.DEFAULT_BOLD
-                titleOptionBuilder.feedTitleTextTypeface(typeface)
-              }
-              FWSystemTypeface.SansSerif.rawValue -> {
-                typeface = Typeface.SANS_SERIF
-                titleOptionBuilder.feedTitleTextTypeface(typeface)
-              }
-              FWSystemTypeface.Serif.rawValue -> {
-                typeface = Typeface.SERIF
-                titleOptionBuilder.feedTitleTextTypeface(typeface)
-              }
-              FWSystemTypeface.Monospace.rawValue -> {
-                typeface = Typeface.MONOSPACE
-                titleOptionBuilder.feedTitleTextTypeface(typeface)
-              }
-              else -> {}
+      typeface?.let {
+        titleOptionBuilder.feedTitleTextTypeface(it)
+      }
+      if (!titleBackgroundColor.isNullOrBlank()) {
+        titleOptionBuilder.feedTitleBackgroundColor(Color.parseColor(titleBackgroundColor))
+      }
+      if (titleGradientDrawable != null) {
+        val orientation = titleGradientDrawable.orientation
+        val colors = titleGradientDrawable.colors
+        if (orientation != null && !colors.isNullOrEmpty()) {
+          var gradientDrawableOrientation = GradientDrawable.Orientation.LEFT_RIGHT
+          when {
+            orientation === FWGradientDrawableOrientation.TOP_BOTTOM -> {
+              gradientDrawableOrientation = GradientDrawable.Orientation.TOP_BOTTOM
+            }
+            orientation === FWGradientDrawableOrientation.TR_BL -> {
+              gradientDrawableOrientation = GradientDrawable.Orientation.TR_BL
+            }
+            orientation === FWGradientDrawableOrientation.RIGHT_LEFT -> {
+              gradientDrawableOrientation = GradientDrawable.Orientation.RIGHT_LEFT
+            }
+            orientation === FWGradientDrawableOrientation.BR_TL -> {
+              gradientDrawableOrientation = GradientDrawable.Orientation.BR_TL
+            }
+            orientation === FWGradientDrawableOrientation.BOTTOM_TOP -> {
+              gradientDrawableOrientation = GradientDrawable.Orientation.BOTTOM_TOP
             }
+            orientation === FWGradientDrawableOrientation.BL_TR -> {
+              gradientDrawableOrientation = GradientDrawable.Orientation.BL_TR
+            }
+            orientation === FWGradientDrawableOrientation.LEFT_RIGHT -> {
+              gradientDrawableOrientation = GradientDrawable.Orientation.BL_TR
+            }
+            orientation === FWGradientDrawableOrientation.TL_BR -> {
+              gradientDrawableOrientation = GradientDrawable.Orientation.TL_BR
+            }
+            else -> {}
           }
-          titleOptionBuilder.feedTitleTextTypeface(typeface)
+          val intColors = colors.map {
+            Color.parseColor(it)
+          }
+          titleOptionBuilder.feedTitleBackgroundDrawable(
+            GradientDrawable(
+              gradientDrawableOrientation,
+              intColors.toIntArray(),
+            )
+          )
         }
       }
     }
 
     when (videoFeedPropsModel.videoFeedConfiguration?.titlePosition) {
-      FWVideoFeedTitlePosition.Nested.rawValue -> {
+      FWVideoFeedTitlePosition.Nested -> {
         layoutOptionBuilder.feedTitlePosition(FeedTitlePosition.NESTED)
       }
-      FWVideoFeedTitlePosition.Stacked.rawValue -> {
+      FWVideoFeedTitlePosition.Stacked -> {
         layoutOptionBuilder.feedTitlePosition(FeedTitlePosition.STACKED)
       }
       else -> {}
@@ -149,7 +184,7 @@ object FWConfigUtil {
       val hidden = playIcon.hidden
       val iconWidth = playIcon.iconWidth
       layoutOptionBuilder.showPlayIcon(hidden != true)
-      if (iconWidth != null && iconWidth > 0) {
+      if (iconWidth != null && iconWidth >= 0) {
         layoutOptionBuilder.playIconWidth(FWCommonUtil.dpToPx(iconWidth.toFloat(), context))
       }
     }
@@ -163,11 +198,12 @@ object FWConfigUtil {
     val adBadgeTextType = adBadgeConfigModel.badgeTextType
     val adBadgeBackgroundColor = adBadgeConfigModel.backgroundColor
     val adBadgeTextColor = adBadgeConfigModel.textColor
+    val adBadgeTypeface = getTypeface(context, adBadgeConfigModel.fontInfo)
     when (adBadgeTextType) {
-      FWVideoPlayerConstant.FW_AD_BADGE_LABEL_AD -> {
+      FWBadgeTextType.Ad -> {
         adBadgeOptionBuilder.adBadgeLabel(AdBadgeTextType.AD)
       }
-      FWVideoPlayerConstant.FW_AD_BADGE_LABEL_SPONSORED -> {
+      FWBadgeTextType.Sponsored -> {
         adBadgeOptionBuilder.adBadgeLabel(AdBadgeTextType.SPONSORED)
       }
       else -> {}
@@ -178,6 +214,9 @@ object FWConfigUtil {
     if (!adBadgeTextColor.isNullOrBlank()) {
       adBadgeOptionBuilder.adBadgeTextColor(Color.parseColor(adBadgeTextColor))
     }
+    adBadgeTypeface?.let {
+      adBadgeOptionBuilder.adBadgeTypeface(it)
+    }
 
     val enableAutoplay = videoFeedPropsModel.videoFeedConfiguration?.enableAutoplay
     enableAutoplay?.let {
@@ -193,33 +232,34 @@ object FWConfigUtil {
       playerOptionBuilder.shareBaseUrl(it)
     }
 
-    if (!FWGlobalDataUtil.appComponentName.isNullOrBlank() && !FWGlobalDataUtil.customCTALinkContentPageRouteName.isNullOrBlank()) {
-      playerOptionBuilder.sdkHandleCtaButtonClick(false)
-    } else {
-      playerOptionBuilder.sdkHandleCtaButtonClick(!FWGlobalDataUtil.customCTAClickEnabled)
-    }
+    playerOptionBuilder.sdkHandleCtaButtonClick(!FWGlobalDataUtil.customCTAClickEnabled)
 
     val gridColumns = videoFeedPropsModel.videoFeedConfiguration?.gridColumns
     if (gridColumns != null && gridColumns > 0) {
       layoutOptionBuilder.columnCount(gridColumns)
     }
 
+    val itemSpacing = videoFeedPropsModel.videoFeedConfiguration?.itemSpacing
+    if (itemSpacing != null && itemSpacing >= 0) {
+      layoutOptionBuilder.itemSpacing(FWCommonUtil.dpToPx(itemSpacing.toFloat(), context) / 2)
+    }
+
     // player config
     when (videoFeedPropsModel.videoPlayerConfiguration?.playerStyle) {
-      FWVideoPlayerConstant.FW_PLAYER_STYLE_FIT -> {
+      FWPlayerStyle.Fit -> {
         playerOptionBuilder.playerMode(PlayerMode.FIT_MODE)
       }
-      FWVideoPlayerConstant.FW_PLAYER_STYLE_FULL -> {
+      FWPlayerStyle.Full -> {
         playerOptionBuilder.playerMode(PlayerMode.FULL_BLEED_MODE)
       }
       else -> {}
     }
 
     when (videoFeedPropsModel.videoPlayerConfiguration?.videoCompleteAction) {
-      FWVideoPlayerConstant.FW_VIDEO_COMPLETE_ACTION_LOOP -> {
+      FWVideoCompleteAction.Loop -> {
         playerOptionBuilder.autoPlayOnComplete(false)
       }
-      FWVideoPlayerConstant.FW_VIDEO_COMPLETE_ACTION_ADVANCE_TO_NEXT -> {
+      FWVideoCompleteAction.AdvanceToNext -> {
         playerOptionBuilder.autoPlayOnComplete(true)
       }
       else -> {}
@@ -235,34 +275,30 @@ object FWConfigUtil {
       playerOptionBuilder.enablePipMode(it)
     }
 
-    val ctaButtonStyle = videoFeedPropsModel.videoPlayerConfiguration?.ctaButtonStyle
-    ctaButtonStyle?.let { style ->
-      val ctaButtonBg = style.backgroundColor
-      val fontSize = style.fontSize
-      val textColor = style.textColor
-      if (!ctaButtonBg.isNullOrBlank()) {
-//        viewOptionsBuilder.ctaButtonBackgroundColor(Color.parseColor(ctaButtonBg))
+    when (videoFeedPropsModel.videoPlayerConfiguration?.ctaWidth) {
+      FWVideoPlayerCTAWidth.FullWidth -> {
+        ctaOptionBuilder.ctaMode(CtaOption.CtaMode.FULL_WIDTH)
       }
-      if (fontSize != null && fontSize > 0) {
-
+      FWVideoPlayerCTAWidth.Compact -> {
+        ctaOptionBuilder.ctaMode(CtaOption.CtaMode.COMPACT)
       }
-      if (!textColor.isNullOrBlank()) {
-//        viewOptionsBuilder.ctaButtonTextColor(Color.parseColor(textColor))
+      FWVideoPlayerCTAWidth.SizeToFit -> {
+        ctaOptionBuilder.ctaMode(CtaOption.CtaMode.SIZE_TO_FIT)
       }
+      else -> {}
     }
 
     val ctaDelay = videoFeedPropsModel.videoPlayerConfiguration?.ctaDelay
     ctaDelay?.let { delay ->
-      delay.type ?: return@let
       delay.value ?: return@let
 
       when (delay.type) {
-        FWVideoPlayerConstant.FW_CTA_DELAY_TYPE_CONSTANT -> {
+        FWCtaDelayType.Constant -> {
           ctaOptionBuilder.ctaDelay(
             CtaDelay(delay.value.toFloat(), CtaDelayUnit.SECONDS)
           )
         }
-        FWVideoPlayerConstant.FW_CTA_DELAY_TYPE_PERCENTAGE -> {
+        FWCtaDelayType.Percentage -> {
           ctaOptionBuilder.ctaDelay(
             CtaDelay(delay.value.toFloat(), CtaDelayUnit.PERCENTAGE)
           )
@@ -271,6 +307,25 @@ object FWConfigUtil {
       }
     }
 
+    val ctaHighlightDelay = videoFeedPropsModel.videoPlayerConfiguration?.ctaHighlightDelay
+    ctaHighlightDelay?.let { delay ->
+      delay.value ?: return@let
+
+      when (delay.type) {
+        FWCtaDelayType.Constant -> {
+          ctaOptionBuilder.ctaHighlightDelay(
+            CtaDelay(delay.value.toFloat(), CtaDelayUnit.SECONDS)
+          )
+        }
+        FWCtaDelayType.Percentage -> {
+          ctaOptionBuilder.ctaHighlightDelay(
+            CtaDelay(delay.value.toFloat(), CtaDelayUnit.PERCENTAGE)
+          )
+        }
+        else -> {}
+      }
+    }
+
     val showMuteButton = videoFeedPropsModel.videoPlayerConfiguration?.showMuteButton
     showMuteButton?.let {
       playerOptionBuilder.showMuteButton(it)
@@ -278,15 +333,7 @@ object FWConfigUtil {
 
     val showPlaybackButton = videoFeedPropsModel.videoPlayerConfiguration?.showPlaybackButton
     showPlaybackButton?.let {
-      playerOptionBuilder.showPlayPauseButton(it)
-    }
-
-    when (videoFeedPropsModel.videoPlayerConfiguration?.launchBehavior) {
-      FWVideoPlayerConstant.FW_PLAYER_LAUNCH_BEHAVIOR_DEFAULT -> {}
-      FWVideoPlayerConstant.FW_PLAYER_LAUNCH_BEHAVIOR_MUTE_ON_FIRST_LAUNCH -> {
-//        viewOptionsBuilder.muteOnLaunch(true)
-      }
-      else -> {}
+      playerOptionBuilder.showPlayPauseButtonInReplay(it)
     }
 
     val showBranding = videoFeedPropsModel.videoPlayerConfiguration?.showBranding
@@ -301,6 +348,7 @@ object FWConfigUtil {
       .baseOption(baseOptionBuilder.build())
       .adBadgeOption(adBadgeOptionBuilder.build())
       .ctaOption(ctaOptionBuilder.build())
+      .adOption(adOptionBuilder.build())
   }
 
   private fun getDefaultLayoutOptionBuilder(): LayoutOption.Builder {
@@ -330,4 +378,35 @@ object FWConfigUtil {
     return CtaOption.Builder()
   }
 
+  private fun getDefaultAdOptionBuilder(): AdOption.Builder {
+    return AdOption.Builder()
+  }
+
+  private fun getTypeface(context: Context, font: FWFontInfoModel?): Typeface? {
+    val typefaceName = font?.typefaceName
+    typefaceName ?: return null
+
+    var typeface = Typeface.DEFAULT
+    if (font.isCustom == true) {
+      typeface = Typeface.createFromAsset(context.assets, typefaceName.rawValue)
+    } else {
+      when (typefaceName) {
+        FWSystemTypeface.DefaultBold -> {
+          typeface = Typeface.DEFAULT_BOLD
+        }
+        FWSystemTypeface.SansSerif -> {
+          typeface = Typeface.SANS_SERIF
+        }
+        FWSystemTypeface.Serif -> {
+          typeface = Typeface.SERIF
+        }
+        FWSystemTypeface.Monospace -> {
+          typeface = Typeface.MONOSPACE
+        }
+        else -> {}
+      }
+    }
+    return typeface
+  }
+
 }

package/android/src/main/java/com/fireworksdk/bridge/utils/FWFragmentUtil.kt

@@ -0,0 +1,51 @@
+package com.fireworksdk.bridge.utils
+
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+
+object FWFragmentUtil {
+
+  fun removeFragmentsFromActivity(fragmentActivity: FragmentActivity?) {
+    fragmentActivity ?: return
+    val fragments = fragmentActivity.supportFragmentManager.fragments
+    for (f in fragments) {
+      removeFragment(fragmentActivity, f)
+    }
+  }
+
+  fun removeFragment(fragmentActivity: FragmentActivity?, fragment: Fragment?, includeChildren: Boolean = true) {
+    fragmentActivity ?: return
+
+    fragment ?: return
+    if (!fragment.isAdded || fragment.isDetached || fragment.isRemoving) {
+      return
+    }
+
+    if (includeChildren) {
+      removeChildFragment(fragment)
+    }
+
+    fragmentActivity.supportFragmentManager.beginTransaction().remove(fragment).commit()
+  }
+
+  private fun removeChildFragment(fragment: Fragment?) {
+    fragment ?: return
+    if (!fragment.isAdded || fragment.isDetached || fragment.isRemoving) {
+      return
+    }
+
+    val cfm = fragment.childFragmentManager
+    val fragments = cfm.fragments
+    if (fragments.isEmpty()) {
+      return
+    }
+
+    for (f in fragments) {
+      removeChildFragment(f)
+      if (!fragment.isAdded || fragment.isDetached || fragment.isRemoving) {
+        continue
+      }
+      cfm.beginTransaction().remove(f).commit()
+    }
+  }
+}

package/android/src/main/java/com/fireworksdk/bridge/utils/FWGlobalDataUtil.kt

@@ -1,6 +1,6 @@
 package com.fireworksdk.bridge.utils
 
-import com.fireworksdk.bridge.components.videofeed.StoryBlockFragment
+import com.fireworksdk.bridge.components.storyblock.StoryBlockFragment
 import com.fireworksdk.bridge.models.FWAdBadgeConfigModel
 import com.fireworksdk.bridge.models.weakProperty
 
@@ -17,8 +17,4 @@ object FWGlobalDataUtil {
   var storyBlockFragment by weakProperty<StoryBlockFragment?>()
 
   var shareBaseUrl: String? = null
-
-  var appComponentName: String? = null
-
-  var customCTALinkContentPageRouteName: String? = null
 }