@juspay-tech/react-native-hyperswitch 0.2.1

package/android/src/main/java/com/hyperswitchsdkreactnative/provider/HyperProvider.kt

@@ -0,0 +1,269 @@
+package com.hyperswitchsdkreactnative.provider
+
+import android.app.Activity
+import android.content.Context
+import android.os.Build
+import android.os.Bundle
+import android.view.View
+import android.webkit.WebSettings
+import android.view.WindowInsets
+import androidx.annotation.RequiresApi
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import androidx.fragment.app.FragmentManager
+import androidx.fragment.app.FragmentTransaction
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.ReadableArray
+import com.hyperswitchsdkreactnative.BuildConfig
+import com.hyperswitchsdkreactnative.internal.ReactFragment
+import org.json.JSONObject
+import org.json.JSONArray
+
+internal class HyperProvider internal constructor(private val activity: Activity) {
+
+  private var customBackendUrl: String? = null
+  private var customLogUrl: String? = null
+  private var customParams: ReadableMap? = null
+  private var clientSecret: String? = null
+
+
+  fun initialise(
+    publishableKey: String?,
+    customBackendUrl: String?,
+    customLogUrl: String?,
+    customParams: ReadableMap?
+  ) {
+    Companion.publishableKey = publishableKey
+    this.customBackendUrl = customBackendUrl
+    this.customLogUrl = customLogUrl
+    this.customParams = customParams
+    try {
+      ReactFragment.initOTAServices(context = activity)
+    } catch (_: Exception) {
+    }
+  }
+
+  fun initPaymentSession(clientSecret: String) {
+    this.clientSecret = clientSecret
+  }
+
+
+  fun presentPaymentSheet(readableMap: ReadableMap) {
+    val activity = activity as? FragmentActivity
+    removeSheetView(true) // remove any existing payment sheet
+    activity?.let {
+      val propsBundle = Bundle().apply {
+        putString("type", "payment")
+        putString("from", "rn")
+        putString("publishableKey", publishableKey ?: "")
+        putString("clientSecret", clientSecret ?: "")
+        putBundle("configuration", readableMapToBundle(readableMap))
+        putBundle("hyperParams", getHyperParams(activity, readableMapToBundle(readableMap)))
+        customBackendUrl?.let { url -> putString("customBackendUrl", url) }
+        customLogUrl?.let { url -> putString("customLogUrl", url) }
+        customParams?.let { params ->
+          putString(
+            "customParams", readableMapToJSON(params).toString()
+          )
+        }
+      }
+
+      val bundle = Bundle().apply {
+        putBundle("props", propsBundle)
+      }
+
+      reactFragment =
+        ReactFragment.Builder().setComponentName("hyperSwitch").setLaunchOptions(bundle).build()
+
+      val fragmentManager: FragmentManager = it.supportFragmentManager
+      val fragmentTransaction: FragmentTransaction = fragmentManager.beginTransaction()
+      fragmentTransaction.add(android.R.id.content, reactFragment!!, "HyperPaymentSheet")
+      fragmentTransaction.addToBackStack("HyperPaymentSheet")
+      fragmentTransaction.commit()
+    } ?: run {
+//      callback(PaymentResult(status = "failed", message = "Activity is not a FragmentActivity"))
+    }
+  }
+
+  fun removeSheetView(reset: Boolean) {
+    val activity = activity as? FragmentActivity
+    activity?.let {
+      try {
+        if (reactFragment != null) {
+          it.supportFragmentManager.beginTransaction().remove(reactFragment!!).commitAllowingStateLoss()
+        }
+        if (reset) {
+          reactFragment = null
+        }
+      } catch (_: Exception) {
+      }
+    }
+  }
+
+  companion object {
+    @JvmStatic
+    var reactFragment: Fragment? = null
+
+    @JvmStatic
+    private var publishableKey: String? = null
+
+    fun publishableKey(): String {
+      return publishableKey ?: ""
+    }
+
+    fun readableMapToJSON(readableMap: ReadableMap?): JSONObject {
+      val json = JSONObject()
+      if (readableMap == null) return json
+
+      val iterator = readableMap.keySetIterator()
+      while (iterator.hasNextKey()) {
+        val key = iterator.nextKey()
+        val type = readableMap.getType(key)
+
+        when (type) {
+          ReadableType.Null -> json.put(key, JSONObject.NULL)
+          ReadableType.Boolean -> json.put(key, readableMap.getBoolean(key))
+          ReadableType.Number -> json.put(key, readableMap.getDouble(key))
+          ReadableType.String -> json.put(key, readableMap.getString(key))
+          ReadableType.Map -> json.put(key, readableMapToJSON(readableMap.getMap(key)))
+          ReadableType.Array -> json.put(key, readableArrayToJSON(readableMap.getArray(key)))
+        }
+      }
+      return json
+    }
+
+    fun readableArrayToJSON(readableArray: ReadableArray?): JSONArray {
+      val json = JSONArray()
+      if (readableArray == null) return json
+
+      for (i in 0 until readableArray.size()) {
+        val type = readableArray.getType(i)
+        when (type) {
+          ReadableType.Null -> json.put(JSONObject.NULL)
+          ReadableType.Boolean -> json.put(readableArray.getBoolean(i))
+          ReadableType.Number -> json.put(readableArray.getDouble(i))
+          ReadableType.String -> json.put(readableArray.getString(i))
+          ReadableType.Map -> json.put(readableMapToJSON(readableArray.getMap(i)))
+          ReadableType.Array -> json.put(readableArrayToJSON(readableArray.getArray(i)))
+        }
+      }
+      return json
+    }
+
+    fun getUserAgent(context: Context): String {
+      return try {
+        WebSettings.getDefaultUserAgent(context)
+      } catch (e: RuntimeException) {
+        System.getProperty("http.agent") ?: ""
+      }
+    }
+
+    fun getCurrentTime(): Double {
+      return System.currentTimeMillis().toDouble()
+    }
+
+    @RequiresApi(Build.VERSION_CODES.R)
+    private fun getRootWindowInsetsCompatR(rootView: View): EdgeInsets? {
+      val insets = rootView.rootWindowInsets?.getInsets(
+        WindowInsets.Type.statusBars() or WindowInsets.Type.displayCutout() or WindowInsets.Type.navigationBars() or WindowInsets.Type.captionBar()
+      ) ?: return null
+      return EdgeInsets(
+        top = insets.top.toFloat(),
+        right = insets.right.toFloat(),
+        bottom = insets.bottom.toFloat(),
+        left = insets.left.toFloat()
+      )
+    }
+
+    private fun getRootWindowInsetsCompatBase(rootView: View): EdgeInsets? {
+      val visibleRect = android.graphics.Rect()
+      rootView.getWindowVisibleDisplayFrame(visibleRect)
+      return EdgeInsets(
+        top = visibleRect.top.toFloat(),
+        right = (rootView.width - visibleRect.right).toFloat(),
+        bottom = (rootView.height - visibleRect.bottom).toFloat(),
+        left = visibleRect.left.toFloat()
+      )
+    }
+
+
+    private fun getBottomInset(context: Activity?): EdgeInsets? {
+      if (context != null) {
+        val rootView = context.window.decorView
+        return when {
+          Build.VERSION.SDK_INT >= Build.VERSION_CODES.R -> getRootWindowInsetsCompatR(
+            rootView
+          )
+
+          else -> getRootWindowInsetsCompatBase(rootView)
+        }
+      } else {
+        return null
+      }
+    }
+
+    private fun getHyperParams(context: Activity, configuration: Bundle): Bundle = Bundle().apply {
+      putString("appId", context.packageName)
+      putString("country", context.resources?.configuration?.locale?.country)
+      putString("user-agent", getUserAgent(context))
+      putDouble("launchTime", getCurrentTime())
+      putString("sdkVersion", BuildConfig.VERSION_NAME)
+      putString("device_model", Build.MODEL)
+      putString("os_type", "android")
+      putString("os_version", Build.VERSION.RELEASE)
+      putString("deviceBrand", Build.BRAND)
+      val edgeInsets = getBottomInset(context as Activity?)
+//        if(edgeInsets!=null) {
+//          putFloat("topInset", edgeInsets.top)
+//          putFloat("leftInset", edgeInsets.left)
+//          putFloat("rightInset", edgeInsets.right)
+//          putFloat("bottomInset", edgeInsets.bottom)
+//        }
+      configuration.getBoolean("disableBranding").let {
+        putBoolean(
+          "disableBranding", it
+        )
+      }
+      configuration.getBoolean("defaultView").let {
+        putBoolean(
+          "defaultView", it
+        )
+      }
+    }
+
+    fun readableMapToBundle(readableMap: ReadableMap?): Bundle {
+      val bundle = Bundle()
+      if (readableMap == null) return bundle
+
+      val iterator = readableMap.keySetIterator()
+      while (iterator.hasNextKey()) {
+        val key = iterator.nextKey()
+        val type = readableMap.getType(key)
+
+        when (type) {
+          ReadableType.Null -> bundle.putString(key, null)
+          ReadableType.Boolean -> bundle.putBoolean(key, readableMap.getBoolean(key))
+          ReadableType.Number -> {
+            val value = readableMap.getDouble(key)
+            if (value % 1 == 0.0) {
+              bundle.putInt(key, value.toInt())
+            } else {
+              bundle.putDouble(key, value)
+            }
+          }
+
+          ReadableType.String -> bundle.putString(key, readableMap.getString(key))
+          ReadableType.Map -> bundle.putBundle(key, readableMapToBundle(readableMap.getMap(key)))
+          ReadableType.Array -> {
+            // Convert array to JSON string for simplicity
+            bundle.putString(key, readableMap.getArray(key)?.toString())
+          }
+        }
+      }
+      return bundle
+    }
+  }
+}
+
+data class EdgeInsets(val top: Float, val right: Float, val bottom: Float, val left: Float)

package/android/src/main/java/com/hyperswitchsdkreactnative/views/GooglePayButtonView.kt

@@ -0,0 +1,60 @@
+package com.hyperswitchsdkreactnative.views
+
+import android.annotation.SuppressLint
+import android.util.Log
+import android.view.View
+import android.widget.FrameLayout
+import com.facebook.react.uimanager.PixelUtil
+import com.facebook.react.uimanager.ThemedReactContext
+import com.google.android.gms.wallet.button.ButtonConstants
+import com.google.android.gms.wallet.button.ButtonOptions
+import com.google.android.gms.wallet.button.PayButton
+
+@SuppressLint("ViewConstructor")
+class GooglePayButtonView(private val context: ThemedReactContext) : FrameLayout(context) {
+
+  var allowedPaymentMethods: String = ""
+  var type = ButtonConstants.ButtonType.PLAIN
+  var theme = ButtonConstants.ButtonTheme.DARK
+  var cornerRadius = 10
+  private var button: PayButton? = null
+
+  fun addButton() {
+    if (button != null) {
+      removeView(button)
+    }
+    button = initializeGooglePayButton()
+    addView(button)
+    viewTreeObserver.addOnGlobalLayoutListener { requestLayout() }
+  }
+
+  private fun initializeGooglePayButton(): PayButton {
+    val googlePayButton = PayButton(context)
+
+    val options =
+      ButtonOptions.newBuilder().setAllowedPaymentMethods(allowedPaymentMethods).setButtonType(type)
+        .setButtonTheme(theme)
+        .setCornerRadius(PixelUtil.toPixelFromDIP(this.cornerRadius.toDouble()).toInt())
+    googlePayButton.initialize(options.build())
+    googlePayButton.setOnClickListener { _ ->
+      // Call the Javascript TouchableOpacity parent where the onClick handler is set
+      (this.parent as? View)?.performClick() ?: run {
+        Log.e("GooglePayReactNative", "Unable to find parent of GooglePayButtonView.")
+      }
+    };
+    return googlePayButton
+  }
+
+  override fun requestLayout() {
+    super.requestLayout()
+    post(mLayoutRunnable)
+  }
+
+  private val mLayoutRunnable = Runnable {
+    measure(
+      MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+      MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
+    )
+    layout(left, top, right, bottom)
+  }
+}

package/android/src/main/java/com/hyperswitchsdkreactnative/views/GooglePayButtonViewManager.kt

@@ -0,0 +1,76 @@
+package com.hyperswitchsdkreactnative.views
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.viewmanagers.GooglePayButtonManagerDelegate
+import com.facebook.react.viewmanagers.GooglePayButtonManagerInterface
+import com.google.android.gms.wallet.button.ButtonConstants
+import java.math.BigInteger
+
+@ReactModule(name = GooglePayButtonViewManager.NAME)
+class GooglePayButtonViewManager : SimpleViewManager<GooglePayButtonView>(),
+  GooglePayButtonManagerInterface<GooglePayButtonView> {
+  private val mDelegate: ViewManagerDelegate<GooglePayButtonView> =
+    GooglePayButtonManagerDelegate(this)
+
+  override fun getDelegate(): ViewManagerDelegate<GooglePayButtonView> {
+    return mDelegate
+  }
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  public override fun createViewInstance(context: ThemedReactContext): GooglePayButtonView {
+    return GooglePayButtonView(context)
+  }
+
+  public override fun onAfterUpdateTransaction(view: GooglePayButtonView) {
+    super.onAfterUpdateTransaction(view)
+    view.addButton()
+  }
+
+  override fun setButtonType(
+    view: GooglePayButtonView?, value: String?
+  ) {
+    view?.type = when (value) {
+      "BUY" -> ButtonConstants.ButtonType.BUY
+      "BOOK" -> ButtonConstants.ButtonType.BOOK
+      "CHECKOUT" -> ButtonConstants.ButtonType.CHECKOUT
+      "DONATE" -> ButtonConstants.ButtonType.DONATE
+      "ORDER" -> ButtonConstants.ButtonType.ORDER
+      "PAY" -> ButtonConstants.ButtonType.PAY
+      "SUBSCRIBE" -> ButtonConstants.ButtonType.SUBSCRIBE
+      else -> ButtonConstants.ButtonType.PLAIN
+    }
+  }
+
+  override fun setButtonStyle(
+    view: GooglePayButtonView?, value: String?
+  ) {
+    view?.theme = when (value) {
+      "light" -> ButtonConstants.ButtonTheme.LIGHT
+      else -> ButtonConstants.ButtonTheme.DARK
+    }
+  }
+
+  override fun setBorderRadius(
+    view: GooglePayButtonView?, value: Double
+  ) {
+    view?.cornerRadius = value.toInt()
+  }
+
+  override fun setAllowedPaymentMethods(
+    view: GooglePayButtonView?, value: String?
+  ) {
+    if (value != null) {
+      view?.allowedPaymentMethods = value
+    }
+  }
+
+  companion object {
+    const val NAME = "GooglePayButton"
+  }
+}

package/android/src/main/java/io/hyperswitch/hyperota/HyperOtaLogger.kt

@@ -0,0 +1,122 @@
+package io.hyperswitch.hyperota
+
+import `in`.juspay.hyperota.TrackerCallback
+import io.hyperswitch.logs.EventName
+import org.json.JSONObject
+import io.hyperswitch.logs.HSLog
+import io.hyperswitch.logs.HyperLogManager
+import io.hyperswitch.logs.LogCategory
+import org.json.JSONException
+
+class HyperOtaLogger : TrackerCallback() {
+
+  private fun createAndSendLog(
+    eventName: EventName,
+    level: String,
+    label: String,
+    category: String,
+    subCategory: String,
+    key: String,
+    value: Any
+  ) {
+    if (!value.toString().contains("index split is empty") && !value.toString()
+        .contains("End of input at character") && !value.toString()
+        .contains("some files during clean up")
+    ) {
+      val eventData = mapOf(
+        "label" to label,
+        "value" to value,
+        "category" to category,
+        "subcategory" to subCategory,
+        "key" to key
+      )
+
+      try {
+        val jsonData = JSONObject(eventData).toString()
+        val log = HSLog.LogBuilder().logType(level).category(LogCategory.OTA_LIFE_CYCLE)
+          .eventName(eventName).value(jsonData).version("0.0.1")
+        HyperLogManager.addLog(log.build())
+      } catch (e: JSONException) {
+      }
+    }
+  }
+
+  override fun track(
+    category: String, subCategory: String, level: String, label: String, key: String, value: Any
+  ) {
+    if (category == "lifecycle") {
+      if (subCategory == "hyperota") {
+        val eventName = when (key) {
+          "init" -> EventName.HYPER_OTA_INIT
+          "end" -> EventName.HYPER_OTA_FINISH
+          else -> EventName.HYPER_OTA_EVENT
+        }
+        createAndSendLog(eventName, level, label, category, subCategory, key, value)
+      } else {
+        createAndSendLog(
+          EventName.HYPER_OTA_EVENT, level, label, category, subCategory, key, value
+        )
+      }
+
+    }
+//        Log.i("ota-1" , "category : " + category + "\n subCategory : " + subCategory +
+//                "\n level : " + level + "\n label : " + label + "\n key : " + key + "\n value : " + value.toString())
+  }
+
+  override fun track(
+    category: String,
+    subCategory: String,
+    level: String,
+    label: String,
+    key: String,
+    value: JSONObject
+  ) {
+    if (category == "lifecycle") {
+      try {
+        val otaVersion = value.getString("package_version")
+        HyperLogManager.setOtaVersion(otaVersion)
+      } catch (_: JSONException) {
+
+      }
+      if (subCategory == "hyperota") {
+        val eventName = when (key) {
+          "init" -> EventName.HYPER_OTA_INIT
+          "end" -> EventName.HYPER_OTA_FINISH
+          else -> EventName.HYPER_OTA_EVENT
+        }
+        createAndSendLog(eventName, level, label, category, subCategory, key, value)
+      } else {
+        createAndSendLog(
+          EventName.HYPER_OTA_EVENT, level, label, category, subCategory, key, value
+        )
+      }
+    }
+//        Log.i("ota-2" , "category : " + category + "\n subCategory : " + subCategory +
+//                "\n level : " + level + "\n label : " + label + "\n key : " + key + "\n value : " + value.toString())
+  }
+
+  override fun trackException(
+    category: String, subCategory: String, label: String, description: String, e: Throwable
+  ) {
+    if (category == "lifecycle") {
+      val eventData = mapOf(
+        "label" to label,
+        "value" to (e.message ?: e.stackTraceToString()),
+        "category" to category,
+        "subcategory" to subCategory
+      )
+
+      try {
+        val jsonData = JSONObject(eventData).toString()
+        val log =
+          HSLog.LogBuilder().logType("error").category(LogCategory.OTA_LIFE_CYCLE)
+            .eventName(EventName.HYPER_OTA_EVENT).value(jsonData)
+
+        HyperLogManager.addLog(log.build())
+      } catch (e: JSONException) {
+      }
+    }
+//        Log.i("ota-3" , "category : " + category + "\n subCategory : " + subCategory +
+//                "\n level : " + "error" + "\n label : " + label + "\n description : " + description + "\n value : " + e.toString())
+  }
+}

package/android/src/main/java/io/hyperswitch/logs/CrashHandler.kt

@@ -0,0 +1,29 @@
+package io.hyperswitch.logs
+
+import android.content.Context
+import org.json.JSONException
+import org.json.JSONObject
+
+class CrashHandler(private val context: Context) : Thread.UncaughtExceptionHandler {
+
+  private val defaultHandler = Thread.getDefaultUncaughtExceptionHandler()
+  private val fileManager = LogFileManager(context)
+  override fun uncaughtException(thread: Thread, throwable: Throwable) {
+    val obj =
+      mapOf(
+        "label" to "crash_detected",
+        "value" to throwable.toString(),
+        "category" to "crash",
+        "subcategory" to "sdk_crash"
+      )
+    try {
+      val jsonData = JSONObject(obj).toString()
+      val log = HSLog.LogBuilder().logType("error").category(LogCategory.USER_EVENT)
+        .eventName(EventName.CRASH_EVENT).value(jsonData).version("0.0.1")
+      HyperLogManager.addLog(log.build())
+    } catch (_: JSONException) {
+    }
+    fileManager.addLog(HyperLogManager.getAllLogsAsString())
+    defaultHandler?.uncaughtException(thread, throwable)
+  }
+}

package/android/src/main/java/io/hyperswitch/logs/Debouncer.kt

@@ -0,0 +1,20 @@
+package io.hyperswitch.logs
+
+import android.os.Handler
+import android.os.Looper
+
+class Debouncer(private val delayInMillis: Long) {
+  private val handler = Handler(Looper.getMainLooper())
+  private var runnable: Runnable? = null
+
+  fun debounce(action: () -> Unit) {
+    cancel()
+    runnable = Runnable { action() }
+    handler.postDelayed(runnable!!, delayInMillis)
+  }
+
+  fun cancel() {
+    runnable?.let { handler.removeCallbacks(it) }
+    runnable = null
+  }
+}

package/android/src/main/java/io/hyperswitch/logs/HyperLogManager.kt

@@ -0,0 +1,113 @@
+package io.hyperswitch.logs
+
+import io.hyperswitch.networking.HyperNetworking
+import io.hyperswitch.react.Utils.Companion.getLoggingUrl
+import org.json.JSONArray
+
+object HyperLogManager {
+
+  private val logsBatch = mutableListOf<HSLog>()
+  private var publishableKey: String? = null
+  private var loggingEndPoint: String? = null
+  private const val DEFAULT_DELAY_IN_MILLIS = 2000L
+  private var delayInMillis: Long = DEFAULT_DELAY_IN_MILLIS
+  private var hyperOtaVersion: String = ""
+  private val debouncer = Debouncer(DEFAULT_DELAY_IN_MILLIS)
+
+  fun initialise(
+    pkKey: String,
+    customLogUrl: String?,
+    delay: Long = DEFAULT_DELAY_IN_MILLIS
+  ) {
+    if (pkKey.isNotBlank()) {
+      publishableKey = pkKey
+      delayInMillis = delay
+      if (customLogUrl != "" && customLogUrl != null) {
+        loggingEndPoint = customLogUrl
+      } else {
+        loggingEndPoint = getLoggingUrl(pkKey)
+      }
+    }
+  }
+
+  fun addLog(log: HSLog) {
+    logsBatch.add(log)
+    debouncedPushLogs()
+  }
+
+  fun sendLogsFromFile(fileManager: LogFileManager) {
+    if (publishableKey.isNullOrBlank()) return
+    try {
+      val logArray = fileManager.getAllLogs()
+      if (logArray.length() > 0) {
+        enrichLogs(logArray)
+        loggingEndPoint?.let { endpoint ->
+          try {
+            HyperNetworking.makePostRequest(
+              endpoint,
+              logArray.toString(),
+              callback = { result ->
+                result.onSuccess {
+                  fileManager.clearFile()
+                }
+              })
+          } catch (_: Exception) {
+          }
+        }
+      }
+    } catch (e: Exception) {
+      e.printStackTrace()
+    }
+  }
+
+  fun setOtaVersion(version: String) {
+    hyperOtaVersion = version
+    debouncedPushLogs()
+  }
+
+  private fun debouncedPushLogs() {
+    debouncer.debounce { sendLogsOverNetwork() }
+  }
+
+  private fun enrichLogs(logsArray: JSONArray) {
+    for (i in 0 until logsArray.length()) {
+      logsArray.getJSONObject(i).apply {
+        put("merchant_id", publishableKey)
+        put("code_push_version", hyperOtaVersion)
+        put("client_core_version", hyperOtaVersion)
+      }
+    }
+  }
+
+  fun getAllLogsAsString(): String =
+    logsBatch.joinToString(prefix = "[", postfix = "]") { it.toJson() }
+
+  private fun sendLogsOverNetwork() {
+    if (logsBatch.isEmpty()) {
+      return
+    }
+    if (!publishableKey.isNullOrBlank() && !loggingEndPoint.isNullOrBlank()) {
+      logsBatch.map { log ->
+        log.apply {
+          merchantId = publishableKey!!
+          codePushVersion = hyperOtaVersion
+          clientCoreVersion = hyperOtaVersion
+        }
+      }
+      val logsToSend = getAllLogsAsString()
+      logsBatch.clear()
+      loggingEndPoint?.let { endpoint ->
+        try {
+          HyperNetworking.makePostRequest(
+            endpoint, logsToSend,
+            callback = {}
+          )
+        } catch (_: Exception) {
+        }
+      }
+    } else {
+      debouncedPushLogs()
+    }
+  }
+
+}