@rejourneyco/react-native 1.0.0

package/android/src/main/java/com/rejourney/utils/Telemetry.kt

@@ -0,0 +1,297 @@
+/**
+ * SDK telemetry and metrics collection.
+ * Android implementation aligned with iOS RJTelemetry.
+ */
+package com.rejourney.utils
+
+import com.rejourney.BuildConfig
+import com.rejourney.core.Logger
+import com.rejourney.core.SDKMetrics
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+
+enum class TelemetryEventType {
+    UPLOAD_SUCCESS,
+    UPLOAD_FAILURE,
+    RETRY_ATTEMPT,
+    CIRCUIT_BREAKER_OPEN,
+    CIRCUIT_BREAKER_CLOSE,
+    MEMORY_PRESSURE_EVICTION,
+    OFFLINE_QUEUE_PERSIST,
+    OFFLINE_QUEUE_RESTORE,
+    SESSION_START,
+    SESSION_END,
+    CRASH_DETECTED,
+    TOKEN_REFRESH
+}
+
+class Telemetry private constructor() {
+
+    companion object {
+        @Volatile
+        private var instance: Telemetry? = null
+
+        fun getInstance(): Telemetry {
+            return instance ?: synchronized(this) {
+                instance ?: Telemetry().also { instance = it }
+            }
+        }
+    }
+
+    private val lock = ReentrantLock()
+
+    private var uploadSuccessCount = 0
+    private var uploadFailureCount = 0
+    private var retryAttemptCount = 0
+    private var circuitBreakerOpenCount = 0
+    private var memoryEvictionCount = 0
+    private var offlinePersistCount = 0
+    private var sessionStartCount = 0
+    private var crashCount = 0
+    private var anrCount = 0
+    private var uploadSuccessRate = 1.0
+    private var avgUploadDurationMs = 0.0
+    private var currentQueueDepth = 0
+    private var lastUploadTime: Long? = null
+    private var lastRetryTime: Long? = null
+
+    private var totalUploadCount = 0
+    private var totalUploadDurationMs = 0L
+    private var totalBytesUploaded = 0L
+    private var totalBytesEvicted = 0L
+
+    fun recordEvent(eventType: TelemetryEventType, metadata: Map<String, Any?>? = null) {
+        lock.withLock {
+            when (eventType) {
+                TelemetryEventType.UPLOAD_SUCCESS -> {
+                    uploadSuccessCount++
+                    lastUploadTime = System.currentTimeMillis()
+                }
+                TelemetryEventType.UPLOAD_FAILURE -> {
+                    uploadFailureCount++
+                }
+                TelemetryEventType.RETRY_ATTEMPT -> {
+                    retryAttemptCount++
+                    lastRetryTime = System.currentTimeMillis()
+                }
+                TelemetryEventType.CIRCUIT_BREAKER_OPEN -> {
+                    circuitBreakerOpenCount++
+                    Logger.warning("[Telemetry] Circuit breaker opened (total: $circuitBreakerOpenCount)")
+                }
+                TelemetryEventType.CIRCUIT_BREAKER_CLOSE -> {
+                    Logger.debug("[Telemetry] Circuit breaker closed")
+                }
+                TelemetryEventType.MEMORY_PRESSURE_EVICTION -> {
+                    memoryEvictionCount++
+                }
+                TelemetryEventType.OFFLINE_QUEUE_PERSIST -> {
+                    offlinePersistCount++
+                    Logger.debug("[Telemetry] Offline queue persisted (total: $offlinePersistCount)")
+                }
+                TelemetryEventType.OFFLINE_QUEUE_RESTORE -> {
+                    Logger.debug("[Telemetry] Offline queue restored")
+                }
+                TelemetryEventType.SESSION_START -> {
+                    sessionStartCount++
+                }
+                TelemetryEventType.SESSION_END -> {
+                    logCurrentMetricsInternal()
+                }
+                TelemetryEventType.CRASH_DETECTED -> {
+                    crashCount++
+                    Logger.warning("[Telemetry] Crash detected (total: $crashCount)")
+                }
+                TelemetryEventType.TOKEN_REFRESH -> {
+                    Logger.debug("[Telemetry] Token refresh triggered")
+                }
+            }
+
+            updateSuccessRate()
+        }
+
+        if (metadata != null) {
+            Logger.debug("[Telemetry] Event metadata: $metadata")
+        }
+    }
+
+    fun recordUploadDuration(durationMs: Long, success: Boolean, byteCount: Long) {
+        lock.withLock {
+            totalUploadCount++
+            totalUploadDurationMs += durationMs
+            avgUploadDurationMs = totalUploadDurationMs.toDouble() / totalUploadCount.toDouble()
+
+            if (success) {
+                totalBytesUploaded += byteCount
+                uploadSuccessCount++
+                lastUploadTime = System.currentTimeMillis()
+            } else {
+                uploadFailureCount++
+            }
+
+            updateSuccessRate()
+        }
+    }
+
+    fun recordFrameEviction(bytesEvicted: Long, frameCount: Int) {
+        lock.withLock {
+            memoryEvictionCount += frameCount
+            totalBytesEvicted += bytesEvicted
+            Logger.warning(
+                "[Telemetry] Memory eviction: $frameCount frames, ${totalBytesEvicted / 1024.0} KB total evicted"
+            )
+        }
+    }
+
+    fun recordQueueDepth(depth: Int) {
+        lock.withLock {
+            currentQueueDepth = depth
+        }
+    }
+
+    fun recordANR() {
+        lock.withLock {
+            anrCount++
+            Logger.warning("[Telemetry] ANR detected (total: $anrCount)")
+        }
+    }
+
+    fun currentMetrics(): SDKMetrics {
+        return lock.withLock {
+            SDKMetrics(
+                uploadSuccessCount = uploadSuccessCount,
+                uploadFailureCount = uploadFailureCount,
+                retryAttemptCount = retryAttemptCount,
+                circuitBreakerOpenCount = circuitBreakerOpenCount,
+                memoryEvictionCount = memoryEvictionCount,
+                offlinePersistCount = offlinePersistCount,
+                sessionStartCount = sessionStartCount,
+                crashCount = crashCount,
+                anrCount = anrCount,
+                uploadSuccessRate = uploadSuccessRate.toFloat(),
+                avgUploadDurationMs = avgUploadDurationMs.toLong(),
+                currentQueueDepth = currentQueueDepth,
+                lastUploadTime = lastUploadTime,
+                lastRetryTime = lastRetryTime,
+                totalBytesUploaded = totalBytesUploaded,
+                totalBytesEvicted = totalBytesEvicted
+            )
+        }
+    }
+
+    fun metricsAsMap(): Map<String, Any?> {
+        val metrics = currentMetrics()
+        return mapOf(
+            "uploadSuccessCount" to metrics.uploadSuccessCount,
+            "uploadFailureCount" to metrics.uploadFailureCount,
+            "retryAttemptCount" to metrics.retryAttemptCount,
+            "circuitBreakerOpenCount" to metrics.circuitBreakerOpenCount,
+            "memoryEvictionCount" to metrics.memoryEvictionCount,
+            "offlinePersistCount" to metrics.offlinePersistCount,
+            "sessionStartCount" to metrics.sessionStartCount,
+            "crashCount" to metrics.crashCount,
+            "anrCount" to metrics.anrCount,
+            "uploadSuccessRate" to metrics.uploadSuccessRate,
+            "avgUploadDurationMs" to metrics.avgUploadDurationMs,
+            "currentQueueDepth" to metrics.currentQueueDepth,
+            "lastUploadTime" to metrics.lastUploadTime,
+            "lastRetryTime" to metrics.lastRetryTime,
+            "totalBytesUploaded" to metrics.totalBytesUploaded,
+            "totalBytesEvicted" to metrics.totalBytesEvicted
+        )
+    }
+
+    fun reset() {
+        lock.withLock {
+            uploadSuccessCount = 0
+            uploadFailureCount = 0
+            retryAttemptCount = 0
+            circuitBreakerOpenCount = 0
+            memoryEvictionCount = 0
+            offlinePersistCount = 0
+            sessionStartCount = 0
+            crashCount = 0
+            anrCount = 0
+            uploadSuccessRate = 1.0
+            avgUploadDurationMs = 0.0
+            currentQueueDepth = 0
+            lastUploadTime = null
+            lastRetryTime = null
+            totalUploadCount = 0
+            totalUploadDurationMs = 0
+            totalBytesUploaded = 0
+            totalBytesEvicted = 0
+        }
+    }
+
+    fun logCurrentMetrics() {
+        if (!BuildConfig.DEBUG) {
+            return
+        }
+
+        lock.withLock {
+            logCurrentMetricsInternal()
+        }
+    }
+
+    private fun logCurrentMetricsInternal() {
+        Logger.debug("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+        Logger.debug(" SDK Telemetry Summary")
+        Logger.debug(
+            "   Uploads: $uploadSuccessCount success, $uploadFailureCount failed (${uploadSuccessRate * 100}%% success rate)"
+        )
+        Logger.debug("   Avg upload latency: ${"%.1f".format(avgUploadDurationMs)} ms")
+        Logger.debug("   Retries: $retryAttemptCount attempts")
+        Logger.debug("   Circuit breaker opens: $circuitBreakerOpenCount")
+        Logger.debug(
+            "   Memory evictions: $memoryEvictionCount frames (${totalBytesEvicted / 1024.0} KB)"
+        )
+        Logger.debug("   Offline persists: $offlinePersistCount")
+        Logger.debug("   Data uploaded: ${totalBytesUploaded / 1024.0} KB")
+        Logger.debug("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+    }
+
+    private fun updateSuccessRate() {
+        val total = uploadSuccessCount + uploadFailureCount
+        uploadSuccessRate = if (total > 0) {
+            uploadSuccessCount.toDouble() / total.toDouble()
+        } else {
+            1.0
+        }
+    }
+
+    fun recordUploadSuccess(durationMs: Long, bytes: Long = 0) {
+        recordUploadDuration(durationMs, true, bytes)
+    }
+
+    fun recordUploadFailure() {
+        recordEvent(TelemetryEventType.UPLOAD_FAILURE)
+    }
+
+    fun recordRetryAttempt() {
+        recordEvent(TelemetryEventType.RETRY_ATTEMPT)
+    }
+
+    fun recordCircuitBreakerOpen() {
+        recordEvent(TelemetryEventType.CIRCUIT_BREAKER_OPEN)
+    }
+
+    fun recordCircuitBreakerClose() {
+        recordEvent(TelemetryEventType.CIRCUIT_BREAKER_CLOSE)
+    }
+
+    fun recordOfflinePersist() {
+        recordEvent(TelemetryEventType.OFFLINE_QUEUE_PERSIST)
+    }
+
+    fun recordSessionStart() {
+        recordEvent(TelemetryEventType.SESSION_START)
+    }
+
+    fun recordCrash() {
+        recordEvent(TelemetryEventType.CRASH_DETECTED)
+    }
+
+    fun updateQueueDepth(depth: Int) {
+        recordQueueDepth(depth)
+    }
+}

package/android/src/main/java/com/rejourney/utils/WindowUtils.kt

@@ -0,0 +1,84 @@
+/**
+ * Window and view utilities.
+ * Android implementation aligned with iOS RJWindowUtils.
+ */
+package com.rejourney.utils
+
+import android.app.Activity
+import android.content.Context
+import android.view.View
+import android.view.Window
+import com.facebook.react.bridge.ReactApplicationContext
+import java.security.SecureRandom
+
+object WindowUtils {
+    private val random = SecureRandom()
+
+    /**
+     * Returns the current key window.
+     */
+    fun keyWindow(context: Context): Window? {
+        return try {
+            when (context) {
+                is ReactApplicationContext -> context.currentActivity?.window
+                is Activity -> context.window
+                else -> null
+            }
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    /**
+     * Get the current activity's window.
+     */
+    fun getCurrentWindow(context: Context): Window? = keyWindow(context)
+
+    /**
+     * Get the current activity.
+     */
+    fun getCurrentActivity(context: Context): Activity? {
+        return try {
+            when (context) {
+                is ReactApplicationContext -> context.currentActivity
+                is Activity -> context
+                else -> null
+            }
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    /**
+     * Finds the accessibility label for a view or its ancestors.
+     */
+    fun accessibilityLabelForView(view: View?): String? {
+        var current = view
+        while (current != null) {
+            val label = current.contentDescription?.toString()?.trim()
+            if (!label.isNullOrEmpty()) {
+                return label
+            }
+            val parent = current.parent
+            current = if (parent is View) parent else null
+        }
+        return null
+    }
+
+    /**
+     * Generates a unique session ID.
+     * Format: session_{timestamp}_{random_hex}
+     */
+    fun generateSessionId(): String {
+        val timestamp = System.currentTimeMillis()
+        val bytes = ByteArray(4)
+        random.nextBytes(bytes)
+        val hex = bytes.joinToString("") { "%02X".format(it) }
+        return "session_${timestamp}_$hex"
+    }
+
+    /**
+     * Returns the current timestamp in milliseconds.
+     */
+    fun currentTimestampMillis(): Long = System.currentTimeMillis()
+}

package/android/src/newarch/java/com/rejourney/RejourneyModule.kt

@@ -0,0 +1,187 @@
+/**
+ * New Architecture (TurboModules) module wrapper for Rejourney SDK.
+ * 
+ * This thin wrapper extends the Codegen-generated NativeRejourneySpec for the New Architecture
+ * and delegates all method implementations to RejourneyModuleImpl.
+ * 
+ * This file is compiled when newArchEnabled=true in gradle.properties.
+ */
+package com.rejourney
+
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.proguard.annotations.DoNotStrip
+import com.rejourney.core.Logger
+
+@ReactModule(name = RejourneyModule.NAME)
+class RejourneyModule(reactContext: ReactApplicationContext) : 
+    NativeRejourneySpec(reactContext) {
+
+    companion object {
+        const val NAME = RejourneyModuleImpl.NAME
+    }
+
+    private var initError: Throwable? = null
+
+    // Lazy initialization to avoid constructor crashes blocking module creation
+    private val impl: RejourneyModuleImpl? by lazy {
+        try {
+            RejourneyModuleImpl(reactContext, isNewArchitecture = true)
+        } catch (e: Throwable) {
+            initError = e
+            Logger.error("✗ CRITICAL: Failed to create RejourneyModuleImpl", e)
+            null
+        }
+    }
+
+    private fun getImplOrReject(promise: Promise): RejourneyModuleImpl? {
+        val instance = impl
+        if (instance == null) {
+            val message = initError?.message ?: "Module initialization failed"
+            promise.resolve(createErrorMap(message))
+            return null
+        }
+        return instance
+    }
+
+    override fun getName(): String = NAME
+
+   @ReactMethod
+   @DoNotStrip
+   override fun debugTriggerANR(durationMs: Double) {
+          val instance = impl
+          if (instance == null) {
+                 Logger.error("debugTriggerANR failed: module not initialized")
+                 return
+          }
+          instance.debugTriggerANR(durationMs)
+   }
+
+    override fun invalidate() {
+          impl?.invalidate()
+        super.invalidate()
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    override fun startSession(userId: String, apiUrl: String, publicKey: String, promise: Promise) {
+           val instance = getImplOrReject(promise) ?: return
+           instance.startSession(userId, apiUrl, publicKey, promise)
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    override fun stopSession(promise: Promise) {
+           val instance = getImplOrReject(promise) ?: return
+           instance.stopSession(promise)
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    override fun logEvent(eventType: String, details: ReadableMap, promise: Promise) {
+           val instance = getImplOrReject(promise) ?: return
+           instance.logEvent(eventType, details, promise)
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    override fun screenChanged(screenName: String, promise: Promise) {
+           val instance = getImplOrReject(promise) ?: return
+           instance.screenChanged(screenName, promise)
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    override fun onScroll(offsetY: Double, promise: Promise) {
+           val instance = getImplOrReject(promise) ?: return
+           instance.onScroll(offsetY, promise)
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    override fun markVisualChange(reason: String, importance: String, promise: Promise) {
+           val instance = getImplOrReject(promise) ?: return
+           instance.markVisualChange(reason, importance, promise)
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    override fun onExternalURLOpened(urlScheme: String, promise: Promise) {
+           val instance = getImplOrReject(promise) ?: return
+           instance.onExternalURLOpened(urlScheme, promise)
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    override fun onOAuthStarted(provider: String, promise: Promise) {
+           val instance = getImplOrReject(promise) ?: return
+           instance.onOAuthStarted(provider, promise)
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    override fun onOAuthCompleted(provider: String, success: Boolean, promise: Promise) {
+           val instance = getImplOrReject(promise) ?: return
+           instance.onOAuthCompleted(provider, success, promise)
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    override fun getSDKMetrics(promise: Promise) {
+           val instance = getImplOrReject(promise) ?: return
+           instance.getSDKMetrics(promise)
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    override fun debugCrash() {
+           val instance = impl
+           if (instance == null) {
+              Logger.error("debugCrash failed: module not initialized")
+              return
+           }
+           instance.debugCrash()
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    override fun getSessionId(promise: Promise) {
+           val instance = getImplOrReject(promise) ?: return
+           instance.getSessionId(promise)
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    override fun maskViewByNativeID(nativeID: String, promise: Promise) {
+           val instance = getImplOrReject(promise) ?: return
+           instance.maskViewByNativeID(nativeID, promise)
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    override fun unmaskViewByNativeID(nativeID: String, promise: Promise) {
+           val instance = getImplOrReject(promise) ?: return
+           instance.unmaskViewByNativeID(nativeID, promise)
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    override fun setUserIdentity(userId: String, promise: Promise) {
+            val instance = getImplOrReject(promise) ?: return
+            instance.setUserIdentity(userId, promise)
+    }
+
+    @ReactMethod
+    @DoNotStrip
+    override fun setDebugMode(enabled: Boolean, promise: Promise) {
+           val instance = getImplOrReject(promise) ?: return
+           instance.setDebugMode(enabled, promise)
+    }
+
+        private fun createErrorMap(error: String): WritableMap {
+            return Arguments.createMap().apply {
+                putBoolean("success", false)
+                putString("error", error)
+            }
+        }
+}

package/android/src/newarch/java/com/rejourney/RejourneyPackage.kt

@@ -0,0 +1,40 @@
+/**
+ * New Architecture (TurboModules) package registration for Rejourney SDK.
+ * 
+ * This package is compiled when newArchEnabled=true in gradle.properties.
+ * It uses BaseReactPackage for proper TurboModule registration.
+ */
+package com.rejourney
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+
+class RejourneyPackage : BaseReactPackage() {
+
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return if (name == RejourneyModuleImpl.NAME) {
+            RejourneyModule(reactContext)
+        } else {
+            null
+        }
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider {
+            mapOf(
+                RejourneyModuleImpl.NAME to ReactModuleInfo(
+                    RejourneyModuleImpl.NAME,      // name
+                    RejourneyModule::class.java.name,  // className (full class name)
+                    false,  // canOverrideExistingModule
+                    false,  // needsEagerInit
+                    false,  // isCxxModule - NOT a C++ module
+                    true    // isTurboModule - MUST be true for TurboModules
+                )
+            )
+        }
+    }
+}