@snowplow/react-native-tracker 1.4.0 → 2.0.0

package/android/src/main/java/com/snowplow/reactnativetracker/ReactNativeTrackerPackage.kt

@@ -0,0 +1,17 @@
+package com.snowplow.reactnativetracker
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+
+class ReactNativeTrackerPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(ReactNativeTrackerModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/android/src/main/java/com/snowplow/reactnativetracker/util/ConfigUtil.kt

@@ -0,0 +1,271 @@
+package com.snowplow.reactnativetracker.util
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.snowplowanalytics.snowplow.configuration.*
+import com.snowplowanalytics.snowplow.emitter.BufferOption
+import com.snowplowanalytics.snowplow.globalcontexts.GlobalContext
+import com.snowplowanalytics.snowplow.payload.SelfDescribingJson
+import com.snowplowanalytics.snowplow.tracker.DevicePlatform
+import com.snowplowanalytics.snowplow.tracker.LogLevel
+import com.snowplowanalytics.snowplow.util.Basis
+import com.snowplowanalytics.snowplow.util.Size
+import com.snowplowanalytics.snowplow.util.TimeMeasure
+import java.util.concurrent.TimeUnit
+
+object ConfigUtil {
+  fun mkTrackerConfiguration(
+    trackerConfig: ReadableMap?,
+    context: ReactApplicationContext
+  ): TrackerConfiguration {
+    val appId = trackerConfig?.getString("appId") ?: context.packageName
+    val trackerConfiguration = TrackerConfiguration(appId)
+      .trackerVersionSuffix(TrackerVersion.RN_TRACKER_VERSION)
+      .screenViewAutotracking(false)
+
+    val trackerConfig = trackerConfig ?: run { return trackerConfiguration }
+    if (trackerConfig.hasKey("devicePlatform")) {
+      val devicePlatform = mkDevicePlatform(trackerConfig.getString("devicePlatform")!!)
+      trackerConfiguration.devicePlatform(devicePlatform)
+    }
+    if (trackerConfig.hasKey("logLevel")) {
+      val logLevel = mkLogLevel(trackerConfig.getString("logLevel")!!)
+      trackerConfiguration.logLevel(logLevel)
+    }
+    if (trackerConfig.hasKey("base64Encoding")) {
+      trackerConfiguration.base64encoding(trackerConfig.getBoolean("base64Encoding"))
+    }
+    if (trackerConfig.hasKey("applicationContext")) {
+      trackerConfiguration.applicationContext(trackerConfig.getBoolean("applicationContext"))
+    }
+    if (trackerConfig.hasKey("platformContext")) {
+      trackerConfiguration.platformContext(trackerConfig.getBoolean("platformContext"))
+    }
+    if (trackerConfig.hasKey("geoLocationContext")) {
+      trackerConfiguration.geoLocationContext(trackerConfig.getBoolean("geoLocationContext"))
+    }
+    if (trackerConfig.hasKey("sessionContext")) {
+      trackerConfiguration.sessionContext(trackerConfig.getBoolean("sessionContext"))
+    }
+    if (trackerConfig.hasKey("screenContext")) {
+      trackerConfiguration.screenContext(trackerConfig.getBoolean("screenContext"))
+    }
+    if (trackerConfig.hasKey("screenViewAutotracking")) {
+      trackerConfiguration.screenViewAutotracking(trackerConfig.getBoolean("screenViewAutotracking"))
+    }
+    if (trackerConfig.hasKey("lifecycleAutotracking")) {
+      trackerConfiguration.lifecycleAutotracking(trackerConfig.getBoolean("lifecycleAutotracking"))
+    }
+    if (trackerConfig.hasKey("installAutotracking")) {
+      trackerConfiguration.installAutotracking(trackerConfig.getBoolean("installAutotracking"))
+    }
+    if (trackerConfig.hasKey("exceptionAutotracking")) {
+      trackerConfiguration.exceptionAutotracking(trackerConfig.getBoolean("exceptionAutotracking"))
+    }
+    if (trackerConfig.hasKey("diagnosticAutotracking")) {
+      trackerConfiguration.diagnosticAutotracking(trackerConfig.getBoolean("diagnosticAutotracking"))
+    }
+    if (trackerConfig.hasKey("deepLinkContext")) {
+      trackerConfiguration.deepLinkContext(trackerConfig.getBoolean("deepLinkContext"))
+    }
+    if (trackerConfig.hasKey("userAnonymisation")) {
+      trackerConfiguration.userAnonymisation(trackerConfig.getBoolean("userAnonymisation"))
+    }
+    return trackerConfiguration
+  }
+
+  fun mkSessionConfiguration(sessionConfig: ReadableMap): SessionConfiguration {
+    val foregroundTimeout = sessionConfig.getDouble("foregroundTimeout").toLong()
+    val backgroundTimeout = sessionConfig.getDouble("backgroundTimeout").toLong()
+    return SessionConfiguration(
+      TimeMeasure(foregroundTimeout, TimeUnit.SECONDS),
+      TimeMeasure(backgroundTimeout, TimeUnit.SECONDS)
+    )
+  }
+
+  fun mkEmitterConfiguration(emitterConfig: ReadableMap): EmitterConfiguration {
+    val emitterConfiguration = EmitterConfiguration()
+    emitterConfig.getString("bufferOption")?.let { opt -> mkBufferOption(opt)?.let { emitterConfiguration.bufferOption(it) } }
+    if (emitterConfig.hasKey("emitRange")) {
+      val emitRange = emitterConfig.getDouble("emitRange").toInt()
+      emitterConfiguration.emitRange(emitRange)
+    }
+    if (emitterConfig.hasKey("threadPoolSize")) {
+      val threadPoolSize = emitterConfig.getDouble("threadPoolSize").toInt()
+      emitterConfiguration.threadPoolSize(threadPoolSize)
+    }
+    if (emitterConfig.hasKey("byteLimitPost")) {
+      val byteLimitPost = emitterConfig.getDouble("byteLimitPost").toInt()
+      emitterConfiguration.byteLimitPost(byteLimitPost)
+    }
+    if (emitterConfig.hasKey("byteLimitGet")) {
+      val byteLimitGet = emitterConfig.getDouble("byteLimitGet").toInt()
+      emitterConfiguration.byteLimitGet(byteLimitGet)
+    }
+    if (emitterConfig.hasKey("serverAnonymisation")) {
+      emitterConfiguration.serverAnonymisation(emitterConfig.getBoolean("serverAnonymisation"))
+    }
+    return emitterConfiguration
+  }
+
+  fun mkSubjectConfiguration(subjectConfig: ReadableMap): SubjectConfiguration {
+    val subjectConfiguration = SubjectConfiguration()
+    if (subjectConfig.hasKey("userId")) {
+      if (subjectConfig.isNull("userId")) {
+        subjectConfiguration.userId(null)
+      } else {
+        subjectConfiguration.userId(subjectConfig.getString("userId"))
+      }
+    }
+    if (subjectConfig.hasKey("networkUserId")) {
+      if (subjectConfig.isNull("networkUserId")) {
+        subjectConfiguration.networkUserId(null)
+      } else {
+        subjectConfiguration.networkUserId(subjectConfig.getString("networkUserId"))
+      }
+    }
+    if (subjectConfig.hasKey("domainUserId")) {
+      if (subjectConfig.isNull("domainUserId")) {
+        subjectConfiguration.domainUserId(null)
+      } else {
+        subjectConfiguration.domainUserId(subjectConfig.getString("domainUserId"))
+      }
+    }
+    if (subjectConfig.hasKey("useragent")) {
+      if (subjectConfig.isNull("useragent")) {
+        subjectConfiguration.useragent(null)
+      } else {
+        subjectConfiguration.useragent(subjectConfig.getString("useragent"))
+      }
+    }
+    if (subjectConfig.hasKey("ipAddress")) {
+      if (subjectConfig.isNull("ipAddress")) {
+        subjectConfiguration.ipAddress(null)
+      } else {
+        subjectConfiguration.ipAddress(subjectConfig.getString("ipAddress"))
+      }
+    }
+    if (subjectConfig.hasKey("timezone")) {
+      if (subjectConfig.isNull("timezone")) {
+        subjectConfiguration.timezone(null)
+      } else {
+        subjectConfiguration.timezone(subjectConfig.getString("timezone"))
+      }
+    }
+    if (subjectConfig.hasKey("language")) {
+      if (subjectConfig.isNull("language")) {
+        subjectConfiguration.language(null)
+      } else {
+        subjectConfiguration.language(subjectConfig.getString("language"))
+      }
+    }
+    if (subjectConfig.hasKey("screenResolution")) {
+      if (subjectConfig.isNull("screenResolution")) {
+        subjectConfiguration.screenResolution(null)
+      } else {
+        val screenRes: ReadableArray = subjectConfig.getArray("screenResolution")!!
+        val screenWidth = screenRes.getDouble(0).toInt()
+        val screenHeight = screenRes.getDouble(1).toInt()
+        val screenResolution = Size(screenWidth, screenHeight)
+        subjectConfiguration.screenResolution(screenResolution)
+      }
+    }
+    if (subjectConfig.hasKey("screenViewport")) {
+      if (subjectConfig.isNull("screenViewport")) {
+        subjectConfiguration.screenViewPort(null)
+      } else {
+        val screenVP: ReadableArray = subjectConfig.getArray("screenViewport")!!
+        val screenVPWidth = screenVP.getDouble(0).toInt()
+        val screenVPHeight = screenVP.getDouble(1).toInt()
+        val screenViewport = Size(screenVPWidth, screenVPHeight)
+        subjectConfiguration.screenViewPort(screenViewport)
+      }
+    }
+    if (subjectConfig.hasKey("colorDepth")) {
+      if (subjectConfig.isNull("colorDepth")) {
+        subjectConfiguration.colorDepth(null)
+      } else {
+        val colorDepth = subjectConfig.getDouble("colorDepth").toInt()
+        subjectConfiguration.colorDepth(colorDepth)
+      }
+    }
+    return subjectConfiguration
+  }
+
+  fun mkGdprConfiguration(gdprConfig: ReadableMap): GdprConfiguration {
+    val basis = mkBasis(gdprConfig.getString("basisForProcessing")!!)
+    val docId: String = gdprConfig.getString("documentId")!!
+    val docVer: String = gdprConfig.getString("documentVersion")!!
+    val docDesc: String = gdprConfig.getString("documentDescription")!!
+    return GdprConfiguration(
+      basis,
+      docId,
+      docVer,
+      docDesc
+    )
+  }
+
+  fun mkGCConfiguration(gcConfig: ReadableArray): GlobalContextsConfiguration {
+    val contextGens: MutableMap<String, GlobalContext> = HashMap()
+    for (i in 0 until gcConfig.size()) {
+      val gcMap: ReadableMap = gcConfig.getMap(i)
+      val itag: String = gcMap.getString("tag")!!
+      val globalContexts: ReadableArray = gcMap.getArray("globalContexts")!!
+      val staticContexts: MutableList<SelfDescribingJson> =
+        ArrayList()
+      for (x in 0 until globalContexts.size()) {
+        val gContext: SelfDescribingJson =
+          EventUtil.createSelfDescribingJson(globalContexts.getMap(x))
+        staticContexts.add(gContext)
+      }
+      val gcStatic = GlobalContext(staticContexts)
+      if (!contextGens.containsKey(itag)) {
+        contextGens[itag] = gcStatic
+      }
+    }
+    return GlobalContextsConfiguration(contextGens)
+  }
+
+  private fun mkDevicePlatform(devPlatform: String): DevicePlatform {
+    return when (devPlatform) {
+      "web" -> DevicePlatform.Web
+      "srv" -> DevicePlatform.ServerSideApp
+      "pc" -> DevicePlatform.Desktop
+      "app" -> DevicePlatform.General
+      "tv" -> DevicePlatform.ConnectedTV
+      "cnsl" -> DevicePlatform.GameConsole
+      "iot" -> DevicePlatform.InternetOfThings
+      else -> DevicePlatform.Mobile
+    }
+  }
+
+  private fun mkLogLevel(logLvl: String): LogLevel {
+    return when (logLvl) {
+      "error" -> LogLevel.ERROR
+      "debug" -> LogLevel.DEBUG
+      "verbose" -> LogLevel.VERBOSE
+      else -> LogLevel.OFF
+    }
+  }
+
+  private fun mkBufferOption(bufferOpt: String): BufferOption? {
+    return when (bufferOpt) {
+      "single" -> BufferOption.Single
+      "default" -> BufferOption.DefaultGroup
+      "large" -> BufferOption.HeavyGroup
+      else -> null
+    }
+  }
+
+  private fun mkBasis(basis: String): Basis {
+    return when (basis) {
+      "contract" -> Basis.CONTRACT
+      "legal_obligation" -> Basis.LEGAL_OBLIGATION
+      "legitimate_interests" -> Basis.LEGITIMATE_INTERESTS
+      "public_task" -> Basis.PUBLIC_TASK
+      "vital_interests" -> Basis.VITAL_INTERESTS
+      else -> Basis.CONSENT
+    }
+  }
+}

package/android/src/main/java/com/snowplow/reactnativetracker/util/EventUtil.kt

@@ -0,0 +1,213 @@
+package com.snowplow.reactnativetracker.util
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.snowplowanalytics.snowplow.event.*
+import com.snowplowanalytics.snowplow.payload.SelfDescribingJson
+import java.util.*
+
+object EventUtil {
+  fun createSelfDescribingJson(json: ReadableMap): SelfDescribingJson {
+    val schema: String = json.getString("schema")!!
+    val dataMap: ReadableMap = json.getMap("data")!!
+    return SelfDescribingJson(schema, dataMap.toHashMap())
+  }
+
+  fun createContexts(contexts: ReadableArray): List<SelfDescribingJson> {
+    val nativeContexts: MutableList<SelfDescribingJson> = ArrayList()
+    for (i in 0 until contexts.size()) {
+      val json = createSelfDescribingJson(contexts.getMap(i))
+      nativeContexts.add(json)
+    }
+    return nativeContexts
+  }
+
+  fun createStructuredEvent(argmap: ReadableMap): Structured {
+    val event = Structured(
+      argmap.getString("category")!!,
+      argmap.getString("action")!!
+    )
+    argmap.getString("label")?.let { event.label(it) }
+    argmap.getString("property")?.let { event.property(it) }
+    // React Native forces primitive double type - so null "value" parameter is handled by not setting at all
+    if (argmap.hasKey("value") && !argmap.isNull("value")) {
+      event.value(argmap.getDouble("value"))
+    }
+    return event
+  }
+
+  fun createScreenViewEvent(argmap: ReadableMap): ScreenView {
+    val name: String = argmap.getString("name")!!
+    val event = if (argmap.hasKey("id")) ScreenView(
+      name,
+      UUID.fromString(argmap.getString("id"))
+    ) else ScreenView(name)
+    argmap.getString("type")?.let { event.type(it) }
+    argmap.getString("previousName")?.let { event.previousName(it) }
+    argmap.getString("previousType")?.let { event.previousType(it) }
+    argmap.getString("previousId")?.let { event.previousId(it) }
+    argmap.getString("transitionType")?.let { event.transitionType(it) }
+    return event
+  }
+
+  fun createPageViewEvent(argmap: ReadableMap): PageView {
+    val event = PageView(argmap.getString("pageUrl")!!)
+    argmap.getString("pageTitle")?.let { event.pageTitle(it) }
+    argmap.getString("referrer")?.let { event.referrer(it) }
+    return event
+  }
+
+  fun createTimingEvent(argmap: ReadableMap): Timing {
+    val event = Timing(
+      argmap.getString("category")!!,
+      argmap.getString("variable")!!,
+      argmap.getDouble("timing").toInt()
+    )
+    argmap.getString("label")?.let { label ->
+      event.label(label)
+    }
+    return event
+  }
+
+  fun createConsentGrantedEvent(argmap: ReadableMap): ConsentGranted {
+    val event = ConsentGranted(
+      argmap.getString("expiry")!!,
+      argmap.getString("documentId")!!,
+      argmap.getString("version")!!
+    )
+    argmap.getString("name")?.let { event.documentName(it) }
+    argmap.getString("documentDescription")?.let { event.documentDescription(it) }
+    return event
+  }
+
+  fun createConsentWithdrawnEvent(argmap: ReadableMap): ConsentWithdrawn {
+    val event = ConsentWithdrawn(
+      argmap.getBoolean("all"),
+      argmap.getString("documentId")!!,
+      argmap.getString("version")!!
+    )
+    argmap.getString("name")?.let { event.documentName(it) }
+    argmap.getString("documentDescription")?.let { event.documentDescription(it) }
+    return event
+  }
+
+  fun createEcommerceTransactionItems(items: ReadableArray): List<EcommerceTransactionItem> {
+    val ecomItems: MutableList<EcommerceTransactionItem> = ArrayList()
+    for (i in 0 until items.size()) {
+      val argItem: ReadableMap = items.getMap(i)
+      val item = EcommerceTransactionItem(
+        argItem.getString("sku")!!,
+        argItem.getDouble("price"),
+        argItem.getDouble("quantity").toInt()
+      )
+      argItem.getString("name")?.let { item.name(it) }
+      argItem.getString("category")?.let { item.category(it) }
+      argItem.getString("currency")?.let { item.currency(it) }
+      ecomItems.add(item)
+    }
+    return ecomItems
+  }
+
+  fun createEcommerceTransactionEvent(argmap: ReadableMap): EcommerceTransaction {
+    val ecomItems = createEcommerceTransactionItems(
+      argmap.getArray("items")!!
+    )
+    val event = EcommerceTransaction(
+      argmap.getString("orderId")!!,
+      argmap.getDouble("totalValue"),
+      ecomItems
+    )
+    argmap.getString("affiliation")?.let { event.affiliation(it) }
+    if (argmap.hasKey("taxValue")) {
+      event.taxValue(argmap.getDouble("taxValue"))
+    }
+    if (argmap.hasKey("shipping")) {
+      event.shipping(argmap.getDouble("shipping"))
+    }
+    argmap.getString("city")?.let { event.city(it) }
+    argmap.getString("state")?.let { event.state(it) }
+    argmap.getString("country")?.let { event.country(it) }
+    argmap.getString("currency")?.let { event.currency(it) }
+    return event
+  }
+
+  fun createDeepLinkReceivedEvent(argmap: ReadableMap): DeepLinkReceived {
+    val event = DeepLinkReceived(
+      argmap.getString("url")!!
+    )
+    argmap.getString("referrer")?.let { event.referrer(it) }
+    return event
+  }
+
+  fun createMessageNotificationAttachments(items: ReadableArray): List<MessageNotificationAttachment> {
+    val attachments: MutableList<MessageNotificationAttachment> = ArrayList()
+    for (i in 0 until items.size()) {
+      val argItem: ReadableMap = items.getMap(i)
+      val attachment = MessageNotificationAttachment(
+        argItem.getString("identifier")!!,
+        argItem.getString("type")!!,
+        argItem.getString("url")!!
+      )
+      attachments.add(attachment)
+    }
+    return attachments
+  }
+
+  fun createStrings(items: ReadableArray): List<String> {
+    val results: MutableList<String> = ArrayList()
+    for (i in 0 until items.size()) {
+      results.add(items.getString(i))
+    }
+    return results
+  }
+
+  fun createMessageNotificationEvent(argmap: ReadableMap): MessageNotification {
+    val trigger: MessageNotificationTrigger
+    trigger =
+      when (argmap.getString("trigger")!!) {
+        "push" -> MessageNotificationTrigger.push
+        "location" -> MessageNotificationTrigger.location
+        "calendar" -> MessageNotificationTrigger.calendar
+        "timeInterval" -> MessageNotificationTrigger.timeInterval
+        else -> MessageNotificationTrigger.other
+      }
+    val event = MessageNotification(
+      argmap.getString("title")!!,
+      argmap.getString("body")!!,
+      trigger
+    )
+    argmap.getString("action")?.let { event.action(it) }
+    if (argmap.hasKey("attachments")) {
+      argmap.getArray("attachments")?.let { attachments ->
+        event.attachments(createMessageNotificationAttachments(attachments))
+      }
+    }
+    if (argmap.hasKey("bodyLocArgs")) {
+      argmap.getArray("bodyLocArgs")?.let { bodyLocArgs ->
+        event.bodyLocArgs(createStrings(bodyLocArgs))
+      }
+    }
+    argmap.getString("bodyLocKey")?.let { event.bodyLocKey(it) }
+    argmap.getString("category")?.let { event.category(it) }
+    if (argmap.hasKey("contentAvailable")) {
+      event.contentAvailable(argmap.getBoolean("contentAvailable"))
+    }
+    argmap.getString("group")?.let { event.group(it) }
+    argmap.getString("icon")?.let { event.icon(it) }
+    if (argmap.hasKey("notificationCount")) {
+      event.notificationCount(argmap.getDouble("notificationCount").toInt())
+    }
+    argmap.getString("notificationTimestamp")?.let { event.notificationTimestamp(it) }
+    argmap.getString("sound")?.let { event.sound(it) }
+    argmap.getString("subtitle")?.let { event.subtitle(it) }
+    argmap.getString("tag")?.let { event.tag(it) }
+    argmap.getString("threadIdentifier")?.let { event.threadIdentifier(it) }
+    if (argmap.hasKey("titleLocArgs")) {
+      argmap.getArray("titleLocArgs")?.let { titleLocArgs ->
+        event.titleLocArgs(createStrings(titleLocArgs))
+      }
+    }
+    argmap.getString("titleLocKey")?.let { event.titleLocKey(it) }
+    return event
+  }
+}

package/android/src/main/java/com/snowplow/reactnativetracker/util/TrackerVersion.kt

@@ -0,0 +1,5 @@
+package com.snowplow.reactnativetracker.util
+
+object TrackerVersion {
+  const val RN_TRACKER_VERSION = "rn-2.0.0"
+}

package/babel.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  presets: ['module:metro-react-native-babel-preset'],
+};

package/example/.watchmanconfig

@@ -0,0 +1 @@
+{}

package/example/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# You may use http://rbenv.org/ or https://rvm.io/ to install and use this version
+ruby ">= 2.6.10"
+
+gem 'cocoapods', '~> 1.12'

package/example/android/app/build.gradle

@@ -0,0 +1,129 @@
+apply plugin: "com.android.application"
+apply plugin: "com.facebook.react"
+
+/**
+ * This is the configuration block to customize your React Native Android app.
+ * By default you don't need to apply any configuration, just uncomment the lines you need.
+ */
+react {
+    /* Folders */
+    //   The root of your project, i.e. where "package.json" lives. Default is '..'
+    // root = file("../")
+    //   The folder where the react-native NPM package is. Default is ../node_modules/react-native
+    // reactNativeDir = file("../node_modules/react-native")
+    //   The folder where the react-native Codegen package is. Default is ../node_modules/@react-native/codegen
+    // codegenDir = file("../node_modules/@react-native/codegen")
+    //   The cli.js file which is the React Native CLI entrypoint. Default is ../node_modules/react-native/cli.js
+    // cliFile = file("../node_modules/react-native/cli.js")
+
+    /* Variants */
+    //   The list of variants to that are debuggable. For those we're going to
+    //   skip the bundling of the JS bundle and the assets. By default is just 'debug'.
+    //   If you add flavors like lite, prod, etc. you'll have to list your debuggableVariants.
+    // debuggableVariants = ["liteDebug", "prodDebug"]
+
+    /* Bundling */
+    //   A list containing the node command and its flags. Default is just 'node'.
+    // nodeExecutableAndArgs = ["node"]
+    //
+    //   The command to run when bundling. By default is 'bundle'
+    // bundleCommand = "ram-bundle"
+    //
+    //   The path to the CLI configuration file. Default is empty.
+    // bundleConfig = file(../rn-cli.config.js)
+    //
+    //   The name of the generated asset file containing your JS bundle
+    // bundleAssetName = "MyApplication.android.bundle"
+    //
+    //   The entry file for bundle generation. Default is 'index.android.js' or 'index.js'
+    // entryFile = file("../js/MyApplication.android.js")
+    //
+    //   A list of extra flags to pass to the 'bundle' commands.
+    //   See https://github.com/react-native-community/cli/blob/main/docs/commands.md#bundle
+    // extraPackagerArgs = []
+
+    /* Hermes Commands */
+    //   The hermes compiler command to run. By default it is 'hermesc'
+    // hermesCommand = "$rootDir/my-custom-hermesc/bin/hermesc"
+    //
+    //   The list of flags to pass to the Hermes compiler. By default is "-O", "-output-source-map"
+    // hermesFlags = ["-O", "-output-source-map"]
+}
+
+/**
+ * Set this to true to Run Proguard on Release builds to minify the Java bytecode.
+ */
+def enableProguardInReleaseBuilds = false
+
+/**
+ * The preferred build flavor of JavaScriptCore (JSC)
+ *
+ * For example, to use the international variant, you can use:
+ * `def jscFlavor = 'org.webkit:android-jsc-intl:+'`
+ *
+ * The international variant includes ICU i18n library and necessary data
+ * allowing to use e.g. `Date.toLocaleString` and `String.localeCompare` that
+ * give correct results when using with locales other than en-US. Note that
+ * this variant is about 6MiB larger per architecture than default.
+ */
+def jscFlavor = 'org.webkit:android-jsc:+'
+
+android {
+    ndkVersion rootProject.ext.ndkVersion
+
+    compileSdkVersion rootProject.ext.compileSdkVersion
+
+    namespace "com.reactnativetrackerexample"
+    defaultConfig {
+        applicationId "com.reactnativetrackerexample"
+        minSdkVersion rootProject.ext.minSdkVersion
+        targetSdkVersion rootProject.ext.targetSdkVersion
+        versionCode 1
+        versionName "1.0"
+        testBuildType System.getProperty('testBuildType', 'debug')
+        testInstrumentationRunner 'androidx.test.runner.AndroidJUnitRunner'
+    }
+    signingConfigs {
+        debug {
+            storeFile file('debug.keystore')
+            storePassword 'android'
+            keyAlias 'androiddebugkey'
+            keyPassword 'android'
+        }
+    }
+    buildTypes {
+        debug {
+            signingConfig signingConfigs.debug
+        }
+        release {
+            // Caution! In production, you need to generate your own keystore file.
+            // see https://reactnative.dev/docs/signed-apk-android.
+            signingConfig signingConfigs.debug
+            minifyEnabled enableProguardInReleaseBuilds
+            proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
+            proguardFile "${rootProject.projectDir}/../node_modules/detox/android/detox/proguard-rules-app.pro"
+        }
+    }
+}
+
+dependencies {
+    // The version of react-native is set by the React Native Gradle Plugin
+    implementation("com.facebook.react:react-android")
+
+    debugImplementation("com.facebook.flipper:flipper:${FLIPPER_VERSION}")
+    debugImplementation("com.facebook.flipper:flipper-network-plugin:${FLIPPER_VERSION}") {
+        exclude group:'com.squareup.okhttp3', module:'okhttp'
+    }
+
+    debugImplementation("com.facebook.flipper:flipper-fresco-plugin:${FLIPPER_VERSION}")
+    if (hermesEnabled.toBoolean()) {
+        implementation("com.facebook.react:hermes-android")
+    } else {
+        implementation jscFlavor
+    }
+
+    androidTestImplementation 'com.wix:detox:+'
+    implementation 'androidx.appcompat:appcompat:1.1.0'
+}
+
+apply from: file("../../node_modules/@react-native-community/cli-platform-android/native_modules.gradle"); applyNativeModulesAppBuildGradle(project)

package/example/android/app/proguard-rules.pro

@@ -0,0 +1,10 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in /usr/local/Cellar/android-sdk/24.3.3/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here: