@rejourneyco/react-native 1.0.0

package/android/src/main/java/com/rejourney/capture/ANRHandler.kt

@@ -0,0 +1,206 @@
+/**
+ * ANR (Application Not Responding) detection handler.
+ * Uses a watchdog pattern to detect when the main thread is unresponsive.
+ */
+package com.rejourney.capture
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.os.Handler
+import android.os.Looper
+import com.rejourney.core.Logger
+import org.json.JSONObject
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicLong
+
+class ANRHandler private constructor(private val context: Context) {
+    
+    companion object {
+        @Volatile
+        private var instance: ANRHandler? = null
+        
+        private const val PREFS_NAME = "rejourney_anr"
+        private const val KEY_ANR_REPORT = "pending_anr_report"
+        private const val KEY_HAS_PENDING = "has_pending_anr"
+        
+        // Default ANR threshold: 5 seconds
+        private const val DEFAULT_THRESHOLD_MS = 5000L
+        // OPTIMIZATION: Watchdog check interval increased to 3 seconds (33% CPU reduction)
+        // Still catches ANRs reliably while reducing background thread overhead
+        private const val CHECK_INTERVAL_MS = 3000L
+
+        fun getInstance(context: Context): ANRHandler {
+            return instance ?: synchronized(this) {
+                instance ?: ANRHandler(context.applicationContext).also { instance = it }
+            }
+        }
+    }
+
+    interface ANRListener {
+        fun onANRDetected(durationMs: Long, threadState: String?)
+    }
+
+    private val prefs: SharedPreferences = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private var watchdogThread: Thread? = null
+    private val isMonitoring = AtomicBoolean(false)
+    private val mainThreadResponded = AtomicBoolean(true)
+    private val lastPingTime = AtomicLong(0)
+    
+    var thresholdMs: Long = DEFAULT_THRESHOLD_MS
+    var listener: ANRListener? = null
+
+    fun startMonitoring() {
+        if (isMonitoring.getAndSet(true)) {
+            return
+        }
+
+        watchdogThread = Thread({
+            while (isMonitoring.get()) {
+                checkMainThread()
+                try {
+                    Thread.sleep(CHECK_INTERVAL_MS)
+                } catch (e: InterruptedException) {
+                    break
+                }
+            }
+        }, "RejourneyANRWatchdog").apply {
+            priority = Thread.NORM_PRIORITY
+            start()
+        }
+
+        Logger.debug("ANR monitoring started (threshold: ${thresholdMs}ms, interval: ${CHECK_INTERVAL_MS}ms)")
+    }
+
+    fun stopMonitoring() {
+        if (!isMonitoring.getAndSet(false)) {
+            return
+        }
+        
+        watchdogThread?.interrupt()
+        watchdogThread = null
+        Logger.debug("ANR monitoring stopped")
+    }
+
+    private fun checkMainThread() {
+        if (!isMonitoring.get()) return
+
+        val now = System.currentTimeMillis()
+
+        // Check if main thread responded to the last ping
+        if (!mainThreadResponded.get()) {
+            val elapsed = now - lastPingTime.get()
+
+            if (elapsed >= thresholdMs) {
+                handleANR(elapsed)
+                mainThreadResponded.set(true)
+            }
+            return
+        }
+
+        // Send new ping to main thread
+        mainThreadResponded.set(false)
+        lastPingTime.set(now)
+
+        mainHandler.post {
+            mainThreadResponded.set(true)
+        }
+    }
+
+    private fun handleANR(durationMs: Long) {
+        Logger.debug("[ANR] ANR DETECTED! Duration: ${durationMs}ms - main thread blocked")
+        
+        // Capture thread state
+        val threadState = captureThreadState()
+        Logger.debug("[ANR] Captured main thread stack (${threadState.length} chars)")
+        
+        // Build ANR report
+        val report = buildANRReport(durationMs, threadState)
+        
+        // Persist to disk
+        persistANRReport(report)
+        
+        // Notify listener handling thread safety internally
+        listener?.onANRDetected(durationMs, threadState)
+    }
+
+    private fun captureThreadState(): String {
+        return try {
+            val mainThread = Looper.getMainLooper().thread
+            mainThread.stackTrace.joinToString("\n") { element ->
+                "\tat $element"
+            }
+        } catch (e: Exception) {
+            "Unable to capture thread state: ${e.message}"
+        }
+    }
+
+    private fun buildANRReport(durationMs: Long, threadState: String?): JSONObject {
+        val mainPrefs = context.getSharedPreferences("rejourney", Context.MODE_PRIVATE)
+        val sessionId = mainPrefs.getString("rj_current_session_id", null)
+
+        return JSONObject().apply {
+            put("timestamp", System.currentTimeMillis())
+            put("durationMs", durationMs)
+            put("type", "anr")
+            put("sessionId", sessionId)
+            put("threadState", threadState)
+            put("platform", "android")
+            put("sdkVersion", com.rejourney.core.Constants.SDK_VERSION)
+            
+            put("deviceMetadata", JSONObject().apply {
+                put("manufacturer", android.os.Build.MANUFACTURER)
+                put("model", android.os.Build.MODEL)
+                put("osVersion", android.os.Build.VERSION.RELEASE)
+                put("sdkInt", android.os.Build.VERSION.SDK_INT)
+            })
+        }
+    }
+
+    private fun persistANRReport(report: JSONObject) {
+        try {
+            prefs.edit()
+                .putString(KEY_ANR_REPORT, report.toString())
+                .putBoolean(KEY_HAS_PENDING, true)
+                .commit()
+            Logger.debug("ANR report persisted to disk")
+        } catch (e: Exception) {
+            Logger.error("Failed to persist ANR report", e)
+        }
+    }
+
+    /**
+     * Check if there's a pending ANR report from previous session.
+     */
+    fun hasPendingANRReport(): Boolean {
+        return prefs.getBoolean(KEY_HAS_PENDING, false)
+    }
+
+    /**
+     * Load and purge the pending ANR report.
+     * Returns the ANR report as a map, or null if none exists.
+     */
+    fun loadAndPurgePendingANRReport(): Map<String, Any?>? {
+        if (!hasPendingANRReport()) return null
+
+        return try {
+            val jsonString = prefs.getString(KEY_ANR_REPORT, null) ?: return null
+            val json = JSONObject(jsonString)
+            
+            // Clear the pending report
+            prefs.edit()
+                .remove(KEY_ANR_REPORT)
+                .putBoolean(KEY_HAS_PENDING, false)
+                .apply()
+
+            // Convert to map
+            json.keys().asSequence().associateWith { key ->
+                json.opt(key)
+            }
+        } catch (e: Exception) {
+            Logger.error("Failed to load pending ANR report", e)
+            prefs.edit().putBoolean(KEY_HAS_PENDING, false).apply()
+            null
+        }
+    }
+}

package/android/src/main/java/com/rejourney/capture/ActivityTracker.kt

@@ -0,0 +1,98 @@
+/**
+ * Activity lifecycle tracking for screen changes.
+ * Android equivalent of iOS RJViewControllerTracker.
+ * 
+ * NOTE: Like iOS, native Activity tracking is DISABLED for React Native apps.
+ * RN apps run inside a single Activity, so native tracking produces noise.
+ * Screen names are tracked via JS-side `screenChanged()`.
+ */
+package com.rejourney.capture
+
+import android.app.Activity
+import android.app.Application
+import android.os.Bundle
+import com.rejourney.core.Logger
+
+/**
+ * Callback interface for activity lifecycle events.
+ */
+interface ActivityTrackerDelegate {
+    fun onActivityChanged(activityName: String, previousActivityName: String?)
+}
+
+class ActivityTracker private constructor() : Application.ActivityLifecycleCallbacks {
+    
+    companion object {
+        @Volatile
+        private var instance: ActivityTracker? = null
+
+        fun getInstance(): ActivityTracker {
+            return instance ?: synchronized(this) {
+                instance ?: ActivityTracker().also { instance = it }
+            }
+        }
+    }
+
+    var delegate: ActivityTrackerDelegate? = null
+    private var isEnabled: Boolean = false
+    private var currentActivityName: String? = null
+    private var previousActivityName: String? = null
+    private var application: Application? = null
+
+    /**
+     * Enable activity tracking.
+     * NOTE: For React Native apps, this should NOT be called - use JS tracking instead.
+     */
+    fun enableTracking(application: Application) {
+        if (isEnabled) return
+        
+        this.application = application
+        application.registerActivityLifecycleCallbacks(this)
+        isEnabled = true
+        Logger.debug("Activity tracking enabled (not recommended for React Native)")
+    }
+
+    /**
+     * Disable activity tracking.
+     */
+    fun disableTracking() {
+        if (!isEnabled) return
+        
+        application?.unregisterActivityLifecycleCallbacks(this)
+        isEnabled = false
+        currentActivityName = null
+        previousActivityName = null
+        Logger.debug("Activity tracking disabled")
+    }
+
+    override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
+
+    override fun onActivityStarted(activity: Activity) {}
+
+    override fun onActivityResumed(activity: Activity) {
+        if (!isEnabled) return
+
+        val activityName = activity.javaClass.simpleName
+        
+        // Only notify if activity actually changed
+        if (activityName != currentActivityName) {
+            previousActivityName = currentActivityName
+            currentActivityName = activityName
+            
+            delegate?.onActivityChanged(activityName, previousActivityName)
+        }
+    }
+
+    override fun onActivityPaused(activity: Activity) {}
+
+    override fun onActivityStopped(activity: Activity) {}
+
+    override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
+
+    override fun onActivityDestroyed(activity: Activity) {}
+
+    /**
+     * Get the current activity name (if tracking is enabled).
+     */
+    fun getCurrentActivityName(): String? = currentActivityName
+}