@jmartins-tillster/analytics-react-native 2.21.3

package/packages/core/android/build.gradle

@@ -0,0 +1,96 @@
+buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["AnalyticsReactNative_kotlinVersion"]
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["AnalyticsReactNative_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["AnalyticsReactNative_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.segmentanalyticsreactnative"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_11
+    targetCompatibility JavaVersion.VERSION_11
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  // Requires sovran for communication
+  implementation project(path: ':segment_sovran-react-native')  
+}
+

package/packages/core/android/gradle.properties

@@ -0,0 +1,5 @@
+AnalyticsReactNative_kotlinVersion=1.7.0
+AnalyticsReactNative_minSdkVersion=21
+AnalyticsReactNative_targetSdkVersion=31
+AnalyticsReactNative_compileSdkVersion=31
+AnalyticsReactNative_ndkversion=21.4.7075529

package/packages/core/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.segmentanalyticsreactnative">
+	<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+</manifest>

package/packages/core/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+	<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+</manifest>

package/packages/core/android/src/main/java/com/segmentanalyticsreactnative/AnalyticsReactNativeModule.kt

@@ -0,0 +1,265 @@
+package com.segmentanalyticsreactnative
+
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageInfo
+import android.content.res.Resources
+import android.media.MediaDrm
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import android.net.Uri
+import android.os.Build
+import android.util.Log
+import androidx.core.content.pm.PackageInfoCompat
+import com.facebook.react.ReactActivity
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import com.sovranreactnative.SovranModule
+import java.lang.Exception
+import java.util.*
+import java.security.MessageDigest
+import java.util.UUID
+
+
+enum class ConnectionType {
+  Cellular, Unknown, Wifi
+}
+
+@ReactModule(name="AnalyticsReactNative")
+class AnalyticsReactNativeModule : ReactContextBaseJavaModule, ActivityEventListener, LifecycleEventListener {
+
+  var onInitialized: () -> Unit = {};
+
+  constructor(reactContext: ReactApplicationContext) : super(reactContext) {
+    this.pInfo = reactContext.packageManager.getPackageInfo(reactContext.packageName, 0)
+    // Listen for new intents when app is in the background
+    reactContext.addActivityEventListener(this)
+    // Listen for resume events when it is cold started, or in the background
+    reactContext.addLifecycleEventListener(this)
+  }
+
+   override fun initialize() {
+    super.initialize()
+    onInitialized()
+   }
+
+  private var isColdLaunch = true
+  private val pInfo: PackageInfo
+
+  override fun getName(): String {
+      return "AnalyticsReactNative"
+  }
+
+  private fun getBuildNumber(): String {
+      return PackageInfoCompat.getLongVersionCode(pInfo).toString()
+    }
+
+  fun ByteArray.toHexString() = joinToString("") { "%02x".format(it) }
+
+  /**
+   * Workaround for not able to get device id on Android 10 or above using DRM API
+   * {@see https://stackoverflow.com/questions/58103580/android-10-imei-no-longer-available-on-api-29-looking-for-alternatives}
+   * {@see https://developer.android.com/training/articles/user-data-ids}
+   */
+  private fun getUniqueId(collectDeviceId : Boolean): String? {
+    if (collectDeviceId) {
+      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR2)
+        return null
+
+      val WIDEVINE_UUID = UUID(-0x121074568629b532L, -0x5c37d8232ae2de13L)
+      var wvDrm: MediaDrm? = null
+      try {
+        wvDrm = MediaDrm(WIDEVINE_UUID)
+        val wideVineId = wvDrm.getPropertyByteArray(MediaDrm.PROPERTY_DEVICE_UNIQUE_ID)
+        val md = MessageDigest.getInstance("SHA-256")
+        md.update(wideVineId)
+        return md.digest().toHexString()
+      } catch (e: Exception) {
+        return null
+      } finally {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+          wvDrm?.close()
+        } else {
+          wvDrm?.release()
+        }
+      }
+    }
+    return null
+  }
+
+  private fun getConnectionType(context: Context): ConnectionType {
+    val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager?
+    var result: ConnectionType = ConnectionType.Unknown
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+      cm?.run {
+        cm.getNetworkCapabilities(cm.activeNetwork)?.run {
+          if (hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
+            result = ConnectionType.Wifi
+          } else if (hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
+            result = ConnectionType.Cellular
+          } else {
+            result = ConnectionType.Unknown
+          }
+        }
+      }
+    } else {
+      cm?.run {
+        cm.activeNetworkInfo?.run {
+          if (type == ConnectivityManager.TYPE_WIFI) {
+            result = ConnectionType.Wifi
+          } else if (type == ConnectivityManager.TYPE_MOBILE) {
+            result = ConnectionType.Cellular
+          } else {
+            result = ConnectionType.Unknown
+          }
+        }
+      }
+    }
+    return result
+  }
+
+  @ReactMethod
+  fun getContextInfo(config: ReadableMap, promise: Promise) {
+    val appName: String = reactApplicationContext.applicationInfo.loadLabel(reactApplicationContext.packageManager).toString()
+    val appVersion: String = pInfo.versionName.toString()
+    val buildNumber = getBuildNumber()
+    val bundleId = reactApplicationContext.packageName
+
+    val connectionType: ConnectionType = getConnectionType(reactApplicationContext)
+    val timezone: TimeZone = TimeZone.getDefault()
+    val currentLocale: Locale = Locale.getDefault()
+    val locale: String = "${currentLocale.language}-${currentLocale.country}"
+
+    val screenWidth =  Resources.getSystem().displayMetrics.widthPixels
+    val screenHeight =  Resources.getSystem().displayMetrics.heightPixels
+
+    val screenDensity = Resources.getSystem().displayMetrics.density;
+
+    val contextInfo: WritableMap = Arguments.createMap()
+
+
+    if (config.hasKey("collectDeviceId") && config.getBoolean("collectDeviceId")) {
+      val fallbackDeviceId = UUID.randomUUID().toString()
+      val deviceId = getUniqueId(config.hasKey("collectDeviceId") && config.getBoolean("collectDeviceId"))?: fallbackDeviceId
+
+      contextInfo.putString("deviceId", deviceId)
+    }
+
+    contextInfo.putString("appName", appName)
+    contextInfo.putString("appVersion", appVersion)
+    contextInfo.putString("buildNumber", buildNumber)
+    contextInfo.putString("bundleId", bundleId)
+
+    contextInfo.putString("deviceName", Build.DEVICE)
+    contextInfo.putString("deviceType", "android")
+    contextInfo.putString("manufacturer", Build.MANUFACTURER)
+    contextInfo.putString("model", Build.MODEL)
+
+    contextInfo.putString("timezone", timezone.id)
+    contextInfo.putString("locale", locale)
+    contextInfo.putString("networkType", connectionType.toString().lowercase(currentLocale))
+
+    contextInfo.putString("osName", "Android")
+    contextInfo.putString("osVersion", Build.VERSION.RELEASE)
+
+    contextInfo.putInt("screenWidth", screenWidth)
+    contextInfo.putInt("screenHeight", screenHeight)
+    contextInfo.putDouble("screenDensity", screenDensity.toDouble())
+
+    promise.resolve(contextInfo)
+  }
+
+  fun getReferrer(activity: Activity): Uri? {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP_MR1) {
+      activity.referrer
+    } else {
+      null
+    }
+  }
+
+  fun trackDeepLinks(intent: Intent?) {
+    if (intent == null || intent.data == null) {
+      Log.d(name, "No Intent data found")
+      return
+    }
+
+    val properties = Hashtable<String, String>()
+
+    if (reactApplicationContext.currentActivity == null) {
+      Log.d(name, "No activity found")
+      return
+    }
+
+    val referrer = getReferrer(reactApplicationContext.currentActivity!!)
+
+    if (referrer != null) {
+      val referringApplication = referrer.toString()
+      properties["referring_application"] = referringApplication
+    }
+
+    val uri = intent.data
+    try {
+      properties["url"] = uri.toString()
+      for (parameter in uri!!.queryParameterNames) {
+        val value = uri.getQueryParameter(parameter)
+        if (value != null && value.trim { it <= ' ' }.isNotEmpty()) {
+          properties[parameter] = value
+        }
+      }
+    } catch (e: Exception) {
+      // handle error
+      Log.d(name, "Error getting URL: ${e.message}")
+      return
+    }
+
+    Log.d(name, "Sending Deeplink data to store: uri=${uri}, referrer=${referrer}")
+    val sovran = (reactApplicationContext.currentActivity?.application as ReactApplication)
+      ?.currentReactContext
+      ?.getNativeModule(SovranModule::class.java)
+    sovran?.dispatch("add-deepLink-data", properties)
+
+
+  }
+
+  fun setAnonymousId(anonymousId: String) {
+    val properties = Hashtable<String, String>()
+    properties["anonymousId"] = anonymousId
+
+    val currentContext = getReactApplicationContext()
+
+    if (currentContext != null) {
+      val sovran = currentContext.getNativeModule(SovranModule::class.java)
+      sovran?.dispatch("add-anonymous-id", properties)
+    }
+  }
+
+  override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
+    // Do nothing
+  }
+
+  override fun onNewIntent(intent: Intent) {
+    Log.d(name, "onNewIntent = ${intent}")
+    trackDeepLinks(intent)
+  }
+
+  override fun onHostResume() {
+    if (reactApplicationContext.currentActivity != null && isColdLaunch) {
+      isColdLaunch = false
+      Log.d(name, "onHostResume = ${reactApplicationContext.currentActivity!!.intent}")
+      trackDeepLinks(reactApplicationContext.currentActivity!!.intent)
+    }
+  }
+
+  override fun onHostPause() {
+    // Do nothing
+  }
+
+  override fun onHostDestroy() {
+    isColdLaunch = true
+    // Do nothing
+  }
+}

package/packages/core/android/src/main/java/com/segmentanalyticsreactnative/AnalyticsReactNativePackage.kt

@@ -0,0 +1,43 @@
+package com.segmentanalyticsreactnative
+
+import java.util.Arrays
+import java.util.Collections
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+import com.facebook.react.bridge.JavaScriptModule
+
+class AnalyticsReactNativePackage : ReactPackage {
+
+    private var isInitialized = false
+    private var anonymousId: String? = null
+    private var module: AnalyticsReactNativeModule? = null
+
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        module = AnalyticsReactNativeModule(reactContext)
+        module?.onInitialized = {
+            isInitialized = true
+            anonymousId?.let { anonId ->
+                module?.setAnonymousId(anonId)
+            }
+        }
+        return listOf(module as NativeModule)
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList<ViewManager<*, *>>()
+    }
+
+    fun setAnonymousId(nativeAnonymousId: String) {
+        if (isInitialized) {
+            anonymousId = nativeAnonymousId;
+            anonymousId?.let { anonId ->
+              module?.setAnonymousId(anonId)
+            }
+        } else {
+            anonymousId = nativeAnonymousId
+        }
+    }
+}

package/packages/core/babel.config.js

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

package/packages/core/constants-generator.js

@@ -0,0 +1,17 @@
+const fs = require('fs');
+const packageJson = require('./package.json');
+
+const body = `
+export const libraryInfo = {
+  name: '${packageJson.name}',
+  version: '${packageJson.version}',
+}
+`;
+
+fs.writeFile('./src/info.ts', body, function (err) {
+  if (err) {
+    return console.log(err);
+  }
+
+  console.log('Configuration file has generated');
+});

package/packages/core/ios/AnalyticsReactNative-Bridging-Header.h

@@ -0,0 +1 @@
+#import <React/RCTBridgeModule.h>

package/packages/core/ios/AnalyticsReactNative.m

@@ -0,0 +1,7 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(AnalyticsReactNative, NSObject)
+
+RCT_EXTERN_METHOD(getContextInfo: (NSDictionary)configuration resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/packages/core/ios/AnalyticsReactNative.swift

@@ -0,0 +1,142 @@
+import CoreTelephony
+import SystemConfiguration
+import UIKit
+import AdSupport
+import sovran_react_native
+
+enum ConnectionType: String {
+    case wifi = "wifi"
+    case cellular = "cellular"
+    case unknown = "unknown"
+}
+
+@objc(AnalyticsReactNative)
+public class AnalyticsReactNative: NSObject {
+    
+    @objc
+    static func requiresMainQueueSetup() -> Bool {
+      return true
+    }
+
+    func getAppName() -> String {
+        guard let displayName = Bundle.main.infoDictionary!["CFBundleDisplayName"] else {
+            return Bundle.main.infoDictionary!["CFBundleName"] as! String
+        }
+        return displayName as! String
+    }
+    
+    func getDeviceModel() -> String {
+        var systemInfo = utsname()
+        uname(&systemInfo)
+        let machineMirror = Mirror(reflecting: systemInfo.machine)
+        return machineMirror.children.reduce("") { identifier, element in
+            guard let value = element.value as? Int8, value != 0 else { return identifier }
+            return identifier + String(UnicodeScalar(UInt8(value)))
+        }
+    }
+    
+    func getDeviceId() -> String {
+        guard let deviceId = UIDevice.current.identifierForVendor else {
+            return "UNKNOWN_ID"
+        }
+        return deviceId.uuidString
+    }
+    
+    func getNetworkType() -> ConnectionType {
+        guard let reachability = SCNetworkReachabilityCreateWithName(kCFAllocatorDefault, "google.com") else {
+            return ConnectionType.unknown
+        }
+
+        var flags = SCNetworkReachabilityFlags()
+        SCNetworkReachabilityGetFlags(reachability, &flags)
+
+        let isReachable = flags.contains(.reachable)
+        let isWWAN = flags.contains(.isWWAN)
+
+        if isReachable {
+            if isWWAN {
+                let networkInfo = CTTelephonyNetworkInfo()
+
+                if #available(iOS 12.1, *) {
+                    let carrierType = networkInfo.serviceCurrentRadioAccessTechnology
+                    guard let _ = carrierType?.first?.value else {
+                        return ConnectionType.unknown
+                    }
+                    return ConnectionType.cellular
+                } else {
+                    let carrierType = networkInfo.currentRadioAccessTechnology
+                    if (carrierType == nil) {
+                        return ConnectionType.unknown
+                    }
+                    return ConnectionType.cellular
+                }
+            } else {
+                return ConnectionType.wifi
+            }
+        }
+
+        return ConnectionType.unknown
+    }
+
+    @objc(getContextInfo:resolver:rejecter:)
+    func getContextInfo(config: NSDictionary, resolver resolve:RCTPromiseResolveBlock, rejecter reject:RCTPromiseRejectBlock) -> Void {
+        let infoDictionary = Bundle.main.infoDictionary!
+
+        let appName = getAppName()
+        let appVersion = infoDictionary["CFBundleShortVersionString"] as? String ?? ""
+        let bundleId = Bundle.main.bundleIdentifier ?? ""
+        let buildNumber = infoDictionary["CFBundleVersion"] as? String ?? ""
+
+        let connectionType: ConnectionType = getNetworkType()
+        var locale = ""
+        if let languageCode = NSLocale.current.languageCode,
+            let regionCode = NSLocale.current.regionCode {
+                locale = "\(languageCode)-\(regionCode)"
+            }
+        let timezone = TimeZone.current.identifier
+
+        let osName = UIDevice.current.systemName
+        let osVersion = UIDevice.current.systemVersion
+
+        let screenWidth = Int(UIScreen.main.bounds.size.width)
+        let screenHeight = Int(UIScreen.main.bounds.size.height)
+
+        let context: [String: Any] = [
+            "appName": appName,
+            "appVersion": appVersion,
+            "buildNumber": buildNumber,
+            "bundleId": bundleId,
+
+            "deviceId": getDeviceId(),
+            "deviceName": UIDevice.current.model,
+            "deviceType": "ios",
+            "manufacturer": "Apple",
+            "model": getDeviceModel(),
+ 
+            "locale": locale,
+            "networkType": "\(connectionType)",
+            "timezone": timezone,
+            
+            "osName": osName,
+            "osVersion": osVersion,
+
+            "screenWidth": screenWidth,
+            "screenHeight": screenHeight
+        ]
+        resolve(context)
+    }
+    
+    @objc(trackDeepLink:withOptions:)
+    public static func trackDeepLink(url: NSURL, options: Dictionary<UIApplication.OpenURLOptionsKey, Any>) -> Void {
+        let urlString = url.absoluteString
+        let referringApp = options[.sourceApplication] as? String ?? ""
+        Sovran.dispatch(action: "add-deepLink-data", payload: [ "referring_application": referringApp, "url":urlString])
+    }
+
+    @objc(setAnonymousId:)
+    public static func setAnonymousId(anonymousId: String) -> Void {
+
+        Sovran.dispatch(action: "add-anonymous-id", payload: ["anonymousId": anonymousId])
+    }
+
+}