react-native-firework-sdk 1.0.0-beta

package/android/src/main/java/com/reactnativefireworksdk/module/FireworkSDKModule.kt

@@ -0,0 +1,248 @@
+package com.reactnativefireworksdk.module
+
+import android.annotation.SuppressLint
+import android.content.pm.PackageManager
+import android.provider.Settings
+import com.facebook.react.bridge.*
+import com.loopnow.fireworklibrary.FwSDK
+import com.loopnow.fireworklibrary.SdkStatus
+import com.loopnow.fireworklibrary.VideoEvent
+import com.reactnativefireworksdk.models.FWVideoPlaybackDetails
+import com.reactnativefireworksdk.models.FWVideoPlaybackSubEventName
+import com.reactnativefireworksdk.models.FWVideoPlayerConfigModel
+import com.reactnativefireworksdk.utils.*
+import org.json.JSONObject
+import com.facebook.react.bridge.ReactMethod
+import com.reactnativefireworksdk.models.FireworkSDKInterface
+
+
+class FireworkSDKModule(
+  reactContext: ReactApplicationContext
+) : ReactContextBaseJavaModule(reactContext), FireworkSDKInterface {
+
+  /**
+   * Initializes FW SDK
+   *
+   * You must add the appid to the AndroidManifest file.
+   * Please contact Firework business team, if you don't have one.
+   *
+   * This method will always return immediately and must be called on the main thread.
+   * It is recommended that you initialize FW SDK when application created. FW SDK must be initialized
+   * before using any of the features.
+   *
+   * @param userId             an id to uniquely identify device or user. If you don't have a unique id
+   *                           We will use hashed Android_ID as it is
+   *                           If id passed is not unique, it will affect the quality of content recommended to the user.
+   */
+  @ReactMethod
+  override fun init(userId: String?, adConfig: ReadableMap?) {
+    init(userId)
+  }
+
+  /**
+   * play video from url with encoded parameters
+   *
+   * When user clicks on player_url shared  @see setBasePlayerUrl and
+   * you handle the universal link in your app, you can launch the video playback
+   * based on the encodedParameters present in the link
+   * the custom player_url is in the format
+   * If you used https://example.com as base url the player_url will be in the following format
+   * https://example.com#fwplayer=eyJjaGFubmVsX2lkIjoiTFJZMUdYIiwiZmVlZF9pZCI6NDIwLCJmZWVkX3R5cGUiOiJkaXNjb3ZlciIsInYiOjEsInZpZGVvX2lkIjoiZ0syNmJkIn0
+   * @param url https://example.com#fwplayer=xxx
+   * @param config { NativeMap: {"playerStyle":"full","videoCompleteAction":"loop","showShareButton":false,"ctaButtonStyle":{"backgroundColor":"#0f7bdf","fontSize":14,"textColor":"#ffffff"}} }
+   */
+  @ReactMethod
+  override fun openVideoPlayer(url: String, config: ReadableMap?) {
+    val encodedParameters = FWUrlUtils.queryParamString(url, "fwplayer")
+    if (encodedParameters.isNullOrBlank()) {
+      FWLogUtils.e { "The parameter url is invalid" }
+      return
+    }
+
+    // set configuration
+    val configMap = config?.toHashMap()
+    val videoPlayerContentConfigModel = FWJsonUtils.fromMap(configMap, FWVideoPlayerConfigModel::class.java)
+    FWVideoPlayerUtils.setVideoPlayerConfig(videoPlayerContentConfigModel)
+
+    // open player
+    UiThreadUtil.runOnUiThread {
+      FwSDK.play(encodedParameters)
+    }
+  }
+
+  /**
+   * The function allows you to set the base url and query parameters to construct
+   * the player_url that is shared when user uses share feature.
+   * The custom url should only be used, if you want to support universal link and
+   * handle opening of the url in the app first before opening it in the web browser.
+   * @param url  for example https://example.com
+   *
+   */
+  @ReactMethod
+  override fun setShareBaseURL(url: String?) {
+    if (!url.isNullOrBlank()) {
+      FwSDK.setBasePlayerUrl(url)
+    }
+  }
+
+  @ReactMethod
+  override fun setCustomCTAClickEnabled(value: Boolean?) {
+    FWVideoPlayerUtils.customCTAClickEnabled = value?:false
+    handleCustomCTAClick()
+  }
+
+  @ReactMethod
+  override fun setVideoPlaybackEventEnabled(value: Boolean?) {
+    FWVideoPlayerUtils.videoPlaybackEventEnabled = value?:false
+    handleVideoPlaybackEvent()
+  }
+
+  private fun init(userId: String?) {
+    val clientId = getAppid()
+    if (clientId.isNullOrBlank()) {
+      val errorMsg = "The appid is invalid"
+      FWLogUtils.e { errorMsg }
+      FWEventUtils.sendInitFailedEvent(reactApplicationContext, errorMsg)
+      return
+    }
+
+    val uid = if (userId.isNullOrBlank()) { getHashedAndroidId() } else userId
+
+    UiThreadUtil.runOnUiThread {
+      FwSDK.initialize(
+        reactApplicationContext,
+        clientId,
+        uid,
+        object : FwSDK.SdkStatusListener {
+          override fun currentStatus(status: SdkStatus, extra: String) {
+            when (status) {
+              SdkStatus.Initialized -> {
+                FWEventUtils.sendInitSuccessEvent(reactApplicationContext)
+              }
+              SdkStatus.InitializationFailed -> {
+                FWEventUtils.sendInitFailedEvent(reactApplicationContext, extra)
+              }
+              SdkStatus.RefreshTokenFailed -> {
+                FWEventUtils.sendInitFailedEvent(reactApplicationContext, extra)
+              }
+              SdkStatus.LoadingContent -> {
+                FWLogUtils.d { "LoadingContent" }
+              }
+              SdkStatus.LoadingContentFailed -> {
+                FWLogUtils.e { "LoadingContentFailed" }
+              }
+              SdkStatus.ContentLoaded -> {
+                FWLogUtils.d { "ContentLoaded" }
+              }
+            }
+          }
+        })
+      handleVideoPlaybackEvent()
+    }
+  }
+
+  private fun getAppid(): String? {
+    val ai = reactApplicationContext.packageManager.getApplicationInfo(
+      reactApplicationContext.packageName,
+      PackageManager.GET_META_DATA
+    )
+    val value = ai.metaData.get("Firework:Appid")
+    return value?.let {
+      it as String
+    } ?: run {
+      null
+    }
+  }
+
+  @SuppressLint("HardwareIds")
+  private fun getHashedAndroidId(): String {
+    val androidId = Settings.Secure.getString(
+      reactApplicationContext.contentResolver,
+      Settings.Secure.ANDROID_ID
+    )
+    return FwSDK.getHash(androidId)
+  }
+
+  private fun handleCustomCTAClick() {
+    if (!FWVideoPlayerUtils.customCTAClickEnabled) {
+      return
+    }
+    FwSDK.ctaClickHandler = object: FwSDK.CtaClickHandler {
+      override fun ctaClicked(label: String, actionUrl: String?): Boolean {
+        FWLogUtils.d { "ctaClicked" }
+        FWEventUtils.sendCustomCTAClickEvent(reactApplicationContext, actionUrl)
+        return FWVideoPlayerUtils.customCTAClickEnabled
+      }
+    }
+  }
+
+  private fun handleVideoPlaybackEvent() {
+    if (!FWVideoPlayerUtils.videoPlaybackEventEnabled) {
+      return
+    }
+    FwSDK.addVideoEventListener(object: FwSDK.VideoEventListener {
+      override fun event(event: String, jsonObject: JSONObject) {
+        val videoPlaybackDetails = FWJsonUtils.fromJson(jsonObject.toString(), FWVideoPlaybackDetails::class.java)
+
+        when (event) {
+          VideoEvent.videoImpression -> {
+            FWEventUtils.sendVideoPlaybackEvent(reactApplicationContext, FWVideoPlaybackSubEventName.Impression.rawValue, videoPlaybackDetails)
+          }
+          VideoEvent.videoStart -> {
+            FWEventUtils.sendVideoPlaybackEvent(reactApplicationContext, FWVideoPlaybackSubEventName.Start.rawValue, videoPlaybackDetails)
+          }
+          VideoEvent.videoFirstQuartile -> {
+            FWEventUtils.sendVideoPlaybackEvent(reactApplicationContext, FWVideoPlaybackSubEventName.FirstQuartile.rawValue, videoPlaybackDetails)
+          }
+          VideoEvent.videoMidpoint -> {
+            FWEventUtils.sendVideoPlaybackEvent(reactApplicationContext, FWVideoPlaybackSubEventName.Midpoint.rawValue, videoPlaybackDetails)
+          }
+          VideoEvent.videoThirdQuartile -> {
+            FWEventUtils.sendVideoPlaybackEvent(reactApplicationContext, FWVideoPlaybackSubEventName.ThirdQuartile.rawValue, videoPlaybackDetails)
+          }
+          VideoEvent.videoComplete -> {
+            FWEventUtils.sendVideoPlaybackEvent(reactApplicationContext, FWVideoPlaybackSubEventName.Complete.rawValue, videoPlaybackDetails)
+          }
+          VideoEvent.videoSession -> {
+
+          }
+          VideoEvent.videoAdStart -> {
+
+          }
+          VideoEvent.videoAdEnd -> {
+            FWEventUtils.sendVideoPlaybackEvent(reactApplicationContext, FWVideoPlaybackSubEventName.AdEnd.rawValue, videoPlaybackDetails)
+          }
+          VideoEvent.videoClickCta -> {
+            FWEventUtils.sendVideoPlaybackEvent(reactApplicationContext, FWVideoPlaybackSubEventName.ClickCTA.rawValue, videoPlaybackDetails)
+          }
+          VideoEvent.videoShare -> {
+            FWEventUtils.sendVideoPlaybackEvent(reactApplicationContext, FWVideoPlaybackSubEventName.ClickShare.rawValue, videoPlaybackDetails)
+          }
+          VideoEvent.videoStartError -> {
+
+          }
+          VideoEvent.videoAdStartError -> {
+
+          }
+        }
+      }
+    })
+  }
+
+  @ReactMethod
+  fun addListener(eventName: String?) {
+    // Set up any upstream listeners or background tasks as necessary
+    FWLogUtils.d { "addListener: $eventName" }
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int?) {
+    // Remove upstream listeners, stop unnecessary background tasks
+    FWLogUtils.d { "removeListeners: $count" }
+  }
+
+  override fun getName(): String {
+    return "FireworkSDK"
+  }
+
+}

package/android/src/main/java/com/reactnativefireworksdk/pages/FWVideoShoppingCartActivity.kt

@@ -0,0 +1,43 @@
+package com.reactnativefireworksdk.pages
+
+import android.app.Activity
+import android.content.Intent
+import android.os.Bundle
+import androidx.appcompat.app.AppCompatActivity
+import androidx.fragment.app.Fragment
+import com.reactnativefireworksdk.R
+import com.facebook.react.ReactFragment
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler
+
+
+class FWVideoShoppingCartActivity : AppCompatActivity(), DefaultHardwareBackBtnHandler {
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    setContentView(R.layout.fwrn_fragment_shoppingcart)
+
+    val reactNativeFragment: Fragment = ReactFragment.Builder()
+      .setComponentName("FWShoppingCartPage")
+      .setLaunchOptions(null)
+      .build()
+
+    supportFragmentManager
+      .beginTransaction()
+      .add(R.id.shopping_cart_container, reactNativeFragment)
+      .commit()
+  }
+
+  companion object {
+
+    fun createIntent(activity: Activity): Intent {
+      val intent = Intent(activity, FWVideoShoppingCartActivity::class.java)
+      intent.flags = Intent.FLAG_ACTIVITY_NO_ANIMATION
+      activity.overridePendingTransition(0, 0)
+      return intent
+    }
+  }
+
+  override fun invokeDefaultOnBackPressed() {
+    super.onBackPressed();
+  }
+}

package/android/src/main/java/com/reactnativefireworksdk/utils/FWEventUtils.kt

@@ -0,0 +1,127 @@
+package com.reactnativefireworksdk.utils
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.uimanager.events.RCTEventEmitter
+import com.reactnativefireworksdk.models.*
+
+object FWEventUtils {
+
+  fun sendInitSuccessEvent(reactContext: ReactContext) {
+    sendEvent(reactContext, FWEventName.SDKIni.rawValue, Arguments.createMap())
+  }
+
+  fun sendInitFailedEvent(reactContext: ReactContext, reason: String?) {
+    val eventMap = Arguments.createMap()
+    val contentMap = Arguments.createMap()
+    contentMap.putString(FWSDKInitSubEventName.InitFailed.rawValue, reason?:"unknown")
+    eventMap.putMap("error", contentMap)
+    sendEvent(reactContext, FWEventName.SDKIni.rawValue, eventMap)
+  }
+
+  fun sendVideoFeedClickEvent(reactContext: ReactContext, info: FWVideoFeedItemDetailsModel) {
+    val eventMap = Arguments.createMap()
+    val contentMap = Arguments.createMap()
+    contentMap.putInt("index", info.index?:0)
+    contentMap.putString("videoId", info.id)
+    contentMap.putInt("duration", info.videoDuration?:0)
+    eventMap.putMap("info", contentMap)
+    sendEvent(reactContext, FWEventName.VideoFeedClick.rawValue, eventMap)
+  }
+
+  fun sendCustomCTAClickEvent(reactContext: ReactContext, url: String?) {
+    val eventMap = Arguments.createMap()
+    eventMap.putString("url", url)
+    sendEvent(reactContext, FWEventName.CustomCTAClick.rawValue, eventMap)
+  }
+
+  fun sendVideoPlaybackEvent(reactContext: ReactContext, eventName: String, info: FWVideoPlaybackDetails?) {
+    val eventMap = Arguments.createMap()
+    eventMap.putString("eventName", eventName)
+
+    val contentMap = Arguments.createMap()
+    if (!info?.videoId.isNullOrBlank()) {
+      contentMap.putString("videoId", info?.videoId)
+    }
+    if (info?.duration != null) {
+      contentMap.putDouble("duration", info.duration.toDouble())
+    }
+    if (info?.caption.isNullOrBlank()) {
+      contentMap.putString("caption", info?.caption)
+    }
+    if (info?.badge.isNullOrBlank()) {
+      contentMap.putString("badge", info?.badge)
+    }
+    if (info?.width != null || info?.height != null) {
+      val playerSizeMap = Arguments.createMap()
+      if (info.width != null) {
+        playerSizeMap.putInt("width", info.width)
+      }
+      if (info.height != null) {
+        playerSizeMap.putInt("height", info.height)
+      }
+      contentMap.putMap("playerSize", playerSizeMap)
+    }
+    if (info?.hasCta != null) {
+      contentMap.putBoolean("hasCTA", info.hasCta)
+    }
+    eventMap.putMap("info", contentMap)
+
+    sendEvent(reactContext, FWEventName.VideoPlayback.rawValue, eventMap)
+  }
+
+  fun sendAddToCartClickEvent(reactContext: ReactContext, productId: String?, unitId: String?, callbackId: Int?) {
+    val eventMap = Arguments.createMap()
+    eventMap.putString("productId", productId)
+    eventMap.putString("unitId", unitId)
+    eventMap.putInt("callbackId", callbackId?:0)
+    sendEvent(reactContext, FWVideoShoppingEventName.AddToCart.rawValue, eventMap)
+  }
+
+  fun sendCartIconClickEvent(reactContext: ReactContext, callbackId: Int?) {
+    val eventMap = Arguments.createMap()
+    eventMap.putInt("callbackId", callbackId?:0)
+    sendEvent(reactContext, FWVideoShoppingEventName.ClickCartIcon.rawValue, eventMap)
+  }
+
+  fun sendUpdateProductDetailsEvent(reactContext: ReactContext, productId: String?, callbackId: Int?) {
+    val eventMap = Arguments.createMap()
+    eventMap.putString("productId", productId)
+    eventMap.putInt("callbackId", callbackId?:0)
+    sendEvent(reactContext, FWVideoShoppingEventName.UpdateProductDetails.rawValue, eventMap)
+  }
+
+  private fun sendEvent(reactContext: ReactContext, eventName: String, params: WritableMap?) {
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(eventName, params)
+  }
+
+  fun receiveVideoFeedLoadFinished(reactContext: ReactContext, targetTag: Int, eventName: String, name: String?, reason: String?) {
+    val eventMap = Arguments.createMap()
+    eventMap.putString("name", name)
+    eventMap.putString("reason", reason)
+    receiveEvent(reactContext, targetTag, FWFeedViewEventName.VideoFeedLoadFinished.rawValue, eventMap)
+  }
+
+  private fun receiveEvent(reactContext: ReactContext, targetTag: Int, eventName: String, event: WritableMap?) {
+    reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(
+      targetTag,
+      eventName,
+      event
+    )
+
+    /**
+     *  ERROR  Invariant Violation: Module RCTModernEventEmitter is not a registered callable module (calling receiveEvent). A frequent cause of the error is that the application entry file path is incorrect.
+     *  This can also happen when the JS bundle is corrupt or there is an early initialization error when loading React Native.
+     */
+//    reactContext.getJSModule(RCTModernEventEmitter::class.java).receiveEvent(
+//      -1,
+//      id,
+//      "onVideoFeedLoadFinished",
+//      event
+//    )
+  }
+}

package/android/src/main/java/com/reactnativefireworksdk/utils/FWJsonUtils.kt

@@ -0,0 +1,57 @@
+package com.reactnativefireworksdk.utils
+
+import android.os.Looper
+import com.fasterxml.jackson.annotation.JsonInclude
+import com.fasterxml.jackson.databind.DeserializationFeature
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.databind.SerializationFeature
+import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
+import java.util.*
+
+object FWJsonUtils {
+  val mapper: ObjectMapper by lazy {
+    jacksonObjectMapper()
+//      .setPropertyNamingStrategy(PropertyNamingStrategy.SNAKE_CASE)
+      .configure(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL, true)
+      .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
+      .setSerializationInclusion(JsonInclude.Include.NON_NULL)
+      .configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false)
+      .configure(SerializationFeature.WRITE_DATES_WITH_ZONE_ID, true)
+      .setTimeZone(TimeZone.getDefault())
+  }
+
+  private fun logJsonError(e: Exception) {
+    val loggedError = RuntimeException("Json Read Error!", e)
+    if (Looper.myLooper() != Looper.getMainLooper()) {
+      throw loggedError
+    }
+  }
+
+  @JvmStatic
+  fun <T> fromMap(map: Map<*, *>?, cls: Class<T>): T? {
+    if (map.isNullOrEmpty()) {
+      return null
+    }
+    try {
+      return mapper.convertValue(map, cls)
+    } catch (e: Exception) {
+      e.printStackTrace()
+      logJsonError(e)
+    }
+    return null
+  }
+
+  @JvmStatic
+  fun <T> fromJson(json: String?, cls: Class<T>): T? {
+    if (json.isNullOrBlank()) {
+      return null
+    }
+    try {
+      return mapper.readValue(json, cls)
+    } catch (e: Exception) {
+      e.printStackTrace()
+      logJsonError(e)
+    }
+    return null
+  }
+}

package/android/src/main/java/com/reactnativefireworksdk/utils/FWLogUtils.kt

@@ -0,0 +1,147 @@
+package com.reactnativefireworksdk.utils
+
+import android.os.Looper
+import android.os.SystemClock
+import android.util.Log
+import com.reactnativefireworksdk.BuildConfig
+import kotlin.math.max
+
+/**
+ * We need to set the [BuildConfig.LOG_LEVEL] to ensure that
+ * the log message whose log level is larger than [BuildConfig.LOG_LEVEL]
+ * can be printed in any environment (Debug / Release).
+ *
+ * P.S The value of [BuildConfig.LOG_LEVEL] is different in the Debug or Release environment.
+ *     see the file - [build.gradle] for detail.
+ */
+object FWLogUtils {
+
+  @JvmStatic
+  var logLevel: Int = BuildConfig.LOG_LEVEL
+
+  @JvmStatic
+  val isDebugEnabled: Boolean get() = logLevel <= Log.DEBUG
+
+  @JvmStatic
+  fun d(lazyMessage: () -> String?) {
+    log(Log.DEBUG, lazyMessage)
+  }
+
+  @JvmStatic
+  fun i(lazyMessage: () -> String?) {
+    log(Log.INFO, lazyMessage)
+  }
+
+  @JvmStatic
+  fun w(lazyMessage: () -> String?) {
+    log(Log.WARN, lazyMessage)
+  }
+
+  @JvmStatic
+  fun e(lazyMessage: () -> String?) {
+    log(Log.ERROR, lazyMessage)
+  }
+
+  @JvmStatic
+  fun d(e: Throwable?) {
+    log(Log.DEBUG, e = e)
+  }
+
+  @JvmStatic
+  fun i(e: Throwable?) {
+    log(Log.INFO, e = e)
+  }
+
+  @JvmStatic
+  fun w(e: Throwable?) {
+    log(Log.WARN, e = e)
+  }
+
+  @JvmStatic
+  @JvmOverloads
+  fun e(e: Throwable?, lazyMessage: (() -> String?)? = null) {
+    log(Log.ERROR, lazyMessage, e)
+  }
+
+  @JvmStatic
+  fun enableMainThreadLog() {
+    var mainThreadStartTime = -1L
+    Looper.getMainLooper().setMessageLogging {
+      if (it.startsWith(">>>>>")) {
+        mainThreadStartTime = SystemClock.uptimeMillis()
+      } else if (it.startsWith("<<<<<")) {
+        val time = SystemClock.uptimeMillis() - mainThreadStartTime
+        // 1000 / 50 = 20+ frames
+        if (time > 50) d {
+          "Using ${time}ms ${it.substring(6)}"
+        }
+      }
+    }
+  }
+
+  private fun log(level: Int, lazyMessage: (() -> String?)? = null, e: Throwable? = null) {
+    if (level >= logLevel) {
+      var message = lazyMessage?.let { it() }.orEmpty()
+      if (message.isEmpty()) {
+        if (e == null) {
+          return
+        } else {
+          message = "null"
+        }
+      }
+      val (tag, lineNumber) = generateTag()
+      val lineTag = when {
+        lineNumber < 10 -> "__$lineNumber"
+        lineNumber < 100 -> "_$lineNumber"
+        else -> "$lineNumber"
+      }
+      while (message.length > 4000) {
+        val subMessage = message.substring(0, 4000)
+        message = message.substring(4000)
+        when (level) {
+          Log.DEBUG -> {
+            Log.d(lineTag, "$tag: $subMessage")
+          }
+          Log.INFO -> {
+            Log.i(lineTag, "$tag: $subMessage")
+          }
+          Log.WARN -> {
+            Log.w(lineTag, "$tag: $subMessage")
+          }
+          Log.ERROR -> {
+            Log.e(lineTag, "$tag: $subMessage")
+          }
+        }
+      }
+      when (level) {
+        Log.DEBUG -> {
+          Log.d(lineTag, "$tag: $message", e)
+        }
+        Log.INFO -> {
+          Log.i(lineTag, "$tag: $message", e)
+        }
+        Log.WARN -> {
+          Log.w(lineTag, "$tag: $message", e)
+        }
+        Log.ERROR -> {
+          Log.e(lineTag, "$tag: $message", e)
+        }
+      }
+    }
+  }
+
+  private val NO_LOG_LIST = setOf(Thread::class.java.name, FWLogUtils::class.java.name)
+
+  internal fun generateTag(): Pair<String, Int> {
+    val stackTrace = Thread.currentThread().stackTrace
+    for (i in 2 until stackTrace.size) {
+      val className = stackTrace[i].className
+      val fileName = stackTrace[i].fileName
+      val lineNumber = stackTrace[i].lineNumber
+      if (className !in NO_LOG_LIST) {
+        return Pair(fileName.substring(0, max(fileName.lastIndexOf('.'), 0)), lineNumber)
+      }
+    }
+    return Pair(javaClass.simpleName, 0)
+  }
+}

package/android/src/main/java/com/reactnativefireworksdk/utils/FWUrlUtils.kt

@@ -0,0 +1,68 @@
+package com.reactnativefireworksdk.utils
+
+import android.net.Uri
+
+object FWUrlUtils {
+
+  /**
+   * Get parameters in URL
+   *
+   * @param urlStr url
+   * @param key key
+   * @return string
+   * e.g. queryParamString("https://www.example.com?a=1&c=2", "a") will return "1"
+   * e.g. queryParamString("https://www.example.com#a=1&c=2", "a") will return "1"
+   */
+  fun queryParamString(urlStr: String?, key: String?): String? {
+    if (urlStr.isNullOrBlank() || key.isNullOrBlank()) {
+      return null
+    }
+    return if (urlStr.contains("#")) {
+      queryHashParamString(urlStr, key)
+    } else {
+      queryBrowserParamString(urlStr, key)
+    }
+  }
+
+  /**
+   * Get browser parameters in URL
+   *
+   * @param urlStr url
+   * @param key key
+   * @return string
+   * e.g. queryParamString("https://www.example.com?a=1&c=2", "a") will return "1"
+   */
+  private fun queryBrowserParamString(urlStr: String?, key: String?): String? {
+    if (urlStr.isNullOrBlank() || key.isNullOrBlank()) {
+      return null
+    }
+    val uri = Uri.parse(urlStr)
+    return uri?.getQueryParameter(key)
+  }
+
+  /**
+   * Get hash parameters in URL
+   *
+   * @param urlStr url
+   * @param key key
+   * @return string
+   * e.g. queryParamString("https://www.example.com#a=1&c=2", "a") will return "1"
+   */
+  private fun queryHashParamString(urlStr: String?, key: String?): String? {
+    if (urlStr.isNullOrBlank() || key.isNullOrBlank()) {
+      return null
+    }
+    val urlParts = urlStr.split("#").filter(String::isNotEmpty)
+    if (urlParts.size < 2) {
+      return null
+    }
+    val query = urlParts[1]
+    val queryParts = query.split("&")
+
+    for (queryPart in queryParts) {
+      val paramParts = queryPart.split("=")
+      if (paramParts[0] == key) return paramParts[1]
+    }
+    return null
+  }
+}