react-native-edgee 1.0.0

package/android/src/main/java/com/reactnativeedgee/EdgeeReactNativeModule.kt

@@ -0,0 +1,369 @@
+package com.reactnativeedgee
+
+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.provider.Settings
+import android.telephony.TelephonyManager
+import android.util.Log
+import android.webkit.WebSettings
+import androidx.core.content.pm.PackageInfoCompat
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import java.lang.Exception
+import java.security.MessageDigest
+import java.util.*
+
+enum class ConnectionType {
+    Cellular, Unknown, Wifi, Ethernet
+}
+
+@ReactModule(name = "EdgeeReactNative")
+class EdgeeReactNativeModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext), ActivityEventListener, LifecycleEventListener {
+
+    private val pInfo: PackageInfo = reactContext.packageManager.getPackageInfo(reactContext.packageName, 0)
+    private var isColdLaunch = true
+
+    init {
+        reactContext.addActivityEventListener(this)
+        reactContext.addLifecycleEventListener(this)
+    }
+
+    override fun getName(): String {
+        return "EdgeeReactNative"
+    }
+
+    private fun getBuildNumber(): String {
+        return PackageInfoCompat.getLongVersionCode(pInfo).toString()
+    }
+
+    private fun ByteArray.toHexString() = joinToString("") { "%02x".format(it) }
+
+    /**
+     * Get unique device identifier using MediaDRM API (privacy-compliant)
+     */
+    private fun getUniqueDeviceId(): String? {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR2) {
+            return null
+        }
+
+        val WIDEVINE_UUID = UUID(-0x121074568629b532L, -0x5c37d8232ae2de13L)
+        var wvDrm: MediaDrm? = null
+        return try {
+            wvDrm = MediaDrm(WIDEVINE_UUID)
+            val wideVineId = wvDrm.getPropertyByteArray(MediaDrm.PROPERTY_DEVICE_UNIQUE_ID)
+            val md = MessageDigest.getInstance("SHA-256")
+            md.update(wideVineId)
+            md.digest().toHexString()
+        } catch (e: Exception) {
+            Log.w("EdgeeReactNative", "Failed to get device ID: ${e.message}")
+            null
+        } finally {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                wvDrm?.close()
+            } else {
+                wvDrm?.release()
+            }
+        }
+    }
+
+    /**
+     * Get Android ID (fallback identifier)
+     */
+    @SuppressLint("HardwareIds")
+    private fun getAndroidId(): String? {
+        return try {
+            Settings.Secure.getString(reactApplicationContext.contentResolver, Settings.Secure.ANDROID_ID)
+        } catch (e: Exception) {
+            Log.w("EdgeeReactNative", "Failed to get Android ID: ${e.message}")
+            null
+        }
+    }
+
+    /**
+     * Detect network connection type
+     */
+    private fun getConnectionType(context: Context): ConnectionType {
+        val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager?
+        var result = ConnectionType.Unknown
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            cm?.run {
+                cm.getNetworkCapabilities(cm.activeNetwork)?.run {
+                    result = when {
+                        hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> ConnectionType.Wifi
+                        hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> ConnectionType.Cellular
+                        hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) -> ConnectionType.Ethernet
+                        else -> ConnectionType.Unknown
+                    }
+                }
+            }
+        } else {
+            @Suppress("DEPRECATION")
+            cm?.run {
+                cm.activeNetworkInfo?.run {
+                    result = when (type) {
+                        ConnectivityManager.TYPE_WIFI -> ConnectionType.Wifi
+                        ConnectivityManager.TYPE_MOBILE -> ConnectionType.Cellular
+                        ConnectivityManager.TYPE_ETHERNET -> ConnectionType.Ethernet
+                        else -> ConnectionType.Unknown
+                    }
+                }
+            }
+        }
+        return result
+    }
+
+    /**
+     * Get carrier information
+     */
+    private fun getCarrierInfo(): Map<String, String?> {
+        return try {
+            val telephonyManager = reactApplicationContext.getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager?
+            mapOf(
+                "carrierName" to telephonyManager?.networkOperatorName,
+                "carrierCode" to telephonyManager?.networkOperator,
+                "isoCountryCode" to telephonyManager?.networkCountryIso?.uppercase()
+            )
+        } catch (e: Exception) {
+            Log.w("EdgeeReactNative", "Failed to get carrier info: ${e.message}")
+            mapOf("carrierName" to null, "carrierCode" to null, "isoCountryCode" to null)
+        }
+    }
+
+    /**
+     * Get user agent string
+     */
+    private fun getUserAgent(): String? {
+        return try {
+            WebSettings.getDefaultUserAgent(reactApplicationContext)
+        } catch (e: Exception) {
+            Log.w("EdgeeReactNative", "Failed to get user agent: ${e.message}")
+            null
+        }
+    }
+
+    /**
+     * Check if device is rooted
+     */
+    private fun isDeviceRooted(): Boolean {
+        return try {
+            val buildTags = Build.TAGS
+            buildTags != null && buildTags.contains("test-keys")
+        } catch (e: Exception) {
+            false
+        }
+    }
+
+    /**
+     * Get memory information
+     */
+    private fun getMemoryInfo(): Map<String, Long> {
+        return try {
+            val runtime = Runtime.getRuntime()
+            mapOf(
+                "totalMemory" to runtime.totalMemory(),
+                "freeMemory" to runtime.freeMemory(),
+                "maxMemory" to runtime.maxMemory()
+            )
+        } catch (e: Exception) {
+            Log.w("EdgeeReactNative", "Failed to get memory info: ${e.message}")
+            mapOf("totalMemory" to 0L, "freeMemory" to 0L, "maxMemory" to 0L)
+        }
+    }
+
+    @ReactMethod
+    fun getContextInfo(config: ReadableMap, promise: Promise) {
+        try {
+            // Basic app information
+            val appName = reactApplicationContext.applicationInfo.loadLabel(reactApplicationContext.packageManager).toString()
+            val appVersion = pInfo.versionName ?: "unknown"
+            val buildNumber = getBuildNumber()
+            val bundleId = reactApplicationContext.packageName
+
+            // Device information
+            val connectionType = getConnectionType(reactApplicationContext)
+            val timezone = TimeZone.getDefault()
+            val currentLocale = Locale.getDefault()
+            val locale = "${currentLocale.language}-${currentLocale.country}"
+
+            // Screen information
+            val displayMetrics = Resources.getSystem().displayMetrics
+            val screenWidth = displayMetrics.widthPixels
+            val screenHeight = displayMetrics.heightPixels
+            val screenDensity = displayMetrics.density
+
+            // Carrier information
+            val carrierInfo = getCarrierInfo()
+
+            // Memory information
+            val memoryInfo = getMemoryInfo()
+
+            // Build context map
+            val contextInfo = Arguments.createMap().apply {
+                // App information
+                putString("appName", appName)
+                putString("appVersion", appVersion)
+                putString("buildNumber", buildNumber)
+                putString("bundleId", bundleId)
+
+                // Device information
+                putString("deviceName", Build.DEVICE)
+                putString("deviceType", "android")
+                putString("manufacturer", Build.MANUFACTURER)
+                putString("model", Build.MODEL)
+                putString("brand", Build.BRAND)
+                putString("product", Build.PRODUCT)
+
+                // System information
+                putString("osName", "Android")
+                putString("osVersion", Build.VERSION.RELEASE)
+                putInt("sdkVersion", Build.VERSION.SDK_INT)
+                putString("kernelVersion", System.getProperty("os.version"))
+
+                // Locale and timezone
+                putString("timezone", timezone.id)
+                putString("locale", locale)
+                putString("language", currentLocale.language)
+                putString("country", currentLocale.country)
+
+                // Network information
+                putString("networkType", connectionType.toString().lowercase(currentLocale))
+                carrierInfo["carrierName"]?.let { putString("carrierName", it) }
+                carrierInfo["carrierCode"]?.let { putString("carrierCode", it) }
+                carrierInfo["isoCountryCode"]?.let { putString("isoCountryCode", it) }
+
+                // Screen information
+                putInt("screenWidth", screenWidth)
+                putInt("screenHeight", screenHeight)
+                putDouble("screenDensity", screenDensity.toDouble())
+
+                // Hardware information
+                putString("architecture", Build.SUPPORTED_ABIS.firstOrNull() ?: "unknown")
+                putBoolean("isTablet", isTablet())
+                putBoolean("isEmulator", isEmulator())
+                putBoolean("isRooted", isDeviceRooted())
+
+                // Memory information
+                putDouble("totalMemoryMB", memoryInfo["totalMemory"]!! / (1024.0 * 1024.0))
+                putDouble("freeMemoryMB", memoryInfo["freeMemory"]!! / (1024.0 * 1024.0))
+                putDouble("maxMemoryMB", memoryInfo["maxMemory"]!! / (1024.0 * 1024.0))
+
+                // Optional device ID (privacy-compliant)
+                if (config.hasKey("collectDeviceId") && config.getBoolean("collectDeviceId")) {
+                    val deviceId = getUniqueDeviceId() ?: getAndroidId() ?: UUID.randomUUID().toString()
+                    putString("deviceId", deviceId)
+                }
+
+                // User agent
+                getUserAgent()?.let { putString("userAgent", it) }
+
+                // Installation info
+                putDouble("firstInstallTime", pInfo.firstInstallTime.toDouble())
+                putDouble("lastUpdateTime", pInfo.lastUpdateTime.toDouble())
+            }
+
+            promise.resolve(contextInfo)
+        } catch (e: Exception) {
+            Log.e("EdgeeReactNative", "Failed to get context info", e)
+            promise.reject("GET_CONTEXT_ERROR", "Failed to get context info: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Check if device is a tablet
+     */
+    private fun isTablet(): Boolean {
+        return try {
+            val displayMetrics = Resources.getSystem().displayMetrics
+            val screenWidthDp = displayMetrics.widthPixels / displayMetrics.density
+            val screenHeightDp = displayMetrics.heightPixels / displayMetrics.density
+            val smallestWidth = minOf(screenWidthDp, screenHeightDp)
+            smallestWidth >= 600 // Android tablet threshold
+        } catch (e: Exception) {
+            false
+        }
+    }
+
+    /**
+     * Check if running on emulator
+     */
+    private fun isEmulator(): Boolean {
+        return (Build.FINGERPRINT.startsWith("generic") ||
+                Build.FINGERPRINT.startsWith("unknown") ||
+                Build.MODEL.contains("google_sdk") ||
+                Build.MODEL.contains("Emulator") ||
+                Build.MODEL.contains("Android SDK built for x86") ||
+                Build.MANUFACTURER.contains("Genymotion") ||
+                Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic") ||
+                "google_sdk" == Build.PRODUCT)
+    }
+
+    /**
+     * Track deep link data
+     */
+    fun trackDeepLinks(intent: Intent?) {
+        if (intent?.data == null) {
+            Log.d(name, "No Intent data found")
+            return
+        }
+
+        val properties = mutableMapOf<String, String>()
+        val uri = intent.data!!
+
+        try {
+            properties["url"] = uri.toString()
+            properties["scheme"] = uri.scheme ?: ""
+            properties["host"] = uri.host ?: ""
+            properties["path"] = uri.path ?: ""
+
+            // Extract query parameters
+            uri.queryParameterNames.forEach { parameter ->
+                uri.getQueryParameter(parameter)?.let { value ->
+                    if (value.trim().isNotEmpty()) {
+                        properties[parameter] = value
+                    }
+                }
+            }
+
+            Log.d(name, "Deep link tracked: $properties")
+        } catch (e: Exception) {
+            Log.e(name, "Error tracking deep link: ${e.message}")
+        }
+    }
+
+    // Activity and lifecycle event handlers
+    override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
+        // No-op
+    }
+
+    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 (cold launch)")
+            trackDeepLinks(reactApplicationContext.currentActivity?.intent)
+        }
+    }
+
+    override fun onHostPause() {
+        // No-op
+    }
+
+    override fun onHostDestroy() {
+        isColdLaunch = true
+    }
+}

package/android/src/main/java/com/reactnativeedgee/EdgeeReactNativePackage.kt

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

package/ios/EdgeeReactNative.m

@@ -0,0 +1,14 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(EdgeeReactNative, NSObject)
+
+RCT_EXTERN_METHOD(getContextInfo:(NSDictionary *)config
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+@end

package/ios/EdgeeReactNative.podspec

@@ -0,0 +1,35 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "../package.json")))
+folly_version = '2021.07.22.00'
+
+Pod::Spec.new do |s|
+  s.name         = "EdgeeReactNative"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "11.0" }
+  s.source       = { :git => "https://github.com/edgee-cloud/react-native-edgee.git", :tag => "#{s.version}" }
+
+  s.source_files = "*.{h,m,mm,swift}"
+
+  s.dependency "React-Core"
+
+  # Don't install the dependencies when we run `pod install` in the old architecture.
+  if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
+    s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
+    s.pod_target_xcconfig    = {
+        "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+        "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+        "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+    }
+    s.dependency "React-Codegen"
+    s.dependency "RCT-Folly", folly_version
+    s.dependency "RCTRequired"
+    s.dependency "RCTTypeSafety"
+    s.dependency "ReactCommon/turbomodule/core"
+  end
+end