@rejourneyco/react-native 1.0.0

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

@@ -0,0 +1,284 @@
+package com.rejourney.utils
+
+import android.content.Context
+import com.rejourney.core.Logger
+import org.json.JSONObject
+import java.io.BufferedReader
+import java.io.File
+import java.io.FileOutputStream
+import java.io.FileReader
+import java.io.OutputStreamWriter
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+
+/**
+ * Write-first event buffer for crash-safe event persistence.
+ *
+ * Android implementation aligned with iOS RJEventBuffer:
+ * - Events are written synchronously to disk on append.
+ * - JSONL format (one JSON object per line).
+ * - Thread-safe via a single lock.
+ */
+class EventBuffer(
+    private val context: Context,
+    private val sessionId: String,
+    private val pendingRootPath: File
+) {
+    private val lock = ReentrantLock()
+    private val eventsFile: File
+    private val metaFile: File
+    private var fileWriter: OutputStreamWriter? = null
+
+    var eventCount: Int = 0
+        private set
+
+    var lastEventTimestamp: Long = 0
+        private set
+
+    private var uploadedEventCount: Int = 0
+    private var isShutdown = false
+
+    init {
+        val sessionDir = File(pendingRootPath, sessionId).apply { mkdirs() }
+        eventsFile = File(sessionDir, "events.jsonl")
+        metaFile = File(sessionDir, "buffer_meta.json")
+
+        if (!eventsFile.exists()) {
+            eventsFile.createNewFile()
+        }
+
+        countExistingEvents()
+        openFileWriter()
+
+        Logger.debug("Event buffer ready: ${eventsFile.absolutePath} ($eventCount existing events)")
+    }
+
+    private fun countExistingEvents() {
+        lock.withLock {
+            try {
+                if (!eventsFile.exists()) {
+                    eventCount = 0
+                    return
+                }
+
+                var count = 0
+                var lastTs = 0L
+
+                BufferedReader(FileReader(eventsFile)).use { reader ->
+                    reader.lineSequence().forEach { line ->
+                        if (line.isNotBlank()) {
+                            try {
+                                val event = JSONObject(line)
+                                count++
+                                val ts = event.optLong("timestamp", 0)
+                                if (ts > lastTs) {
+                                    lastTs = ts
+                                }
+                            } catch (_: Exception) {
+                            }
+                        }
+                    }
+                }
+
+                eventCount = count
+                lastEventTimestamp = lastTs
+
+                if (metaFile.exists()) {
+                    try {
+                        val meta = JSONObject(metaFile.readText())
+                        uploadedEventCount = meta.optInt("uploadedEventCount", 0)
+                    } catch (_: Exception) {
+                    }
+                }
+            } catch (e: Exception) {
+                Logger.warning("Failed to count existing events: ${e.message}")
+                eventCount = 0
+            }
+        }
+    }
+
+    private fun openFileWriter() {
+        lock.withLock {
+            try {
+                fileWriter = OutputStreamWriter(
+                    FileOutputStream(eventsFile, true),
+                    Charsets.UTF_8
+                )
+            } catch (e: Exception) {
+                Logger.error("Failed to open events file for writing", e)
+            }
+        }
+    }
+
+    fun appendEvent(event: Map<String, Any?>): Boolean {
+        if (isShutdown) {
+            Logger.warning("[EventBuffer] appendEvent: Buffer is shutdown, rejecting event type=${event["type"]}")
+            return false
+        }
+
+        return lock.withLock {
+            writeEventToDisk(event)
+        }
+    }
+
+    fun appendEvents(events: List<Map<String, Any?>>): Boolean {
+        if (events.isEmpty()) return true
+        if (isShutdown) return false
+
+        return lock.withLock {
+            var allSuccess = true
+            events.forEach { event ->
+                if (!writeEventToDisk(event)) {
+                    allSuccess = false
+                }
+            }
+            allSuccess
+        }
+    }
+
+    private fun writeEventToDisk(event: Map<String, Any?>): Boolean {
+        val writer = fileWriter ?: return false
+
+        return try {
+            val jsonObject = JSONObject()
+            event.forEach { (key, value) ->
+                when (value) {
+                    is Map<*, *> -> {
+                        val nested = JSONObject()
+                        value.forEach { (nestedKey, nestedValue) ->
+                            if (nestedKey is String) {
+                                nested.put(nestedKey, nestedValue)
+                            }
+                        }
+                        jsonObject.put(key, nested)
+                    }
+                    is List<*> -> jsonObject.put(key, org.json.JSONArray(value))
+                    else -> jsonObject.put(key, value)
+                }
+            }
+
+            val line = jsonObject.toString() + "\n"
+            writer.write(line)
+            writer.flush()
+
+            eventCount++
+            val ts = event["timestamp"] as? Long ?: (event["timestamp"] as? Number)?.toLong()
+            if (ts != null) {
+                lastEventTimestamp = ts
+            }
+
+            true
+        } catch (e: Exception) {
+            Logger.warning("Failed to write event: ${e.message}")
+            false
+        }
+    }
+
+    fun flush(): Boolean {
+        return lock.withLock {
+            try {
+                fileWriter?.flush()
+                true
+            } catch (e: Exception) {
+                Logger.error("[EventBuffer] flush: Failed to flush events", e)
+                false
+            }
+        }
+    }
+
+    fun readAllEvents(): List<Map<String, Any?>> {
+        return lock.withLock {
+            try {
+                if (!eventsFile.exists()) {
+                    return@withLock emptyList()
+                }
+
+                val events = mutableListOf<Map<String, Any?>>()
+                BufferedReader(FileReader(eventsFile)).use { reader ->
+                    reader.lineSequence().forEach { line ->
+                        if (line.isNotBlank()) {
+                            try {
+                                val json = JSONObject(line)
+                                val map = mutableMapOf<String, Any?>()
+                                json.keys().forEach { key ->
+                                    map[key] = json.opt(key)
+                                }
+                                events.add(map)
+                            } catch (_: Exception) {
+                            }
+                        }
+                    }
+                }
+
+                events
+            } catch (e: Exception) {
+                Logger.error("[EventBuffer] readAllEvents: Failed to read events", e)
+                emptyList()
+            }
+        }
+    }
+
+    fun readEventsAfterBatchNumber(afterBatchNumber: Int): List<Map<String, Any?>> {
+        val allEvents = readAllEvents()
+        val startIndex = lock.withLock {
+            maxOf(uploadedEventCount, maxOf(0, afterBatchNumber))
+        }
+        if (startIndex >= allEvents.size) {
+            return emptyList()
+        }
+        return allEvents.subList(startIndex, allEvents.size)
+    }
+
+    fun readPendingEvents(): List<Map<String, Any?>> {
+        val allEvents = readAllEvents()
+        if (uploadedEventCount >= allEvents.size) {
+            return emptyList()
+        }
+        return allEvents.subList(uploadedEventCount, allEvents.size)
+    }
+
+    fun markEventsUploadedUpToIndex(eventIndex: Int) {
+        lock.withLock {
+            uploadedEventCount = eventIndex
+
+            try {
+                val meta = JSONObject().apply {
+                    put("uploadedEventCount", uploadedEventCount)
+                    put("lastEventTimestamp", lastEventTimestamp)
+                }
+                metaFile.writeText(meta.toString())
+            } catch (e: Exception) {
+                Logger.warning("Failed to save buffer meta: ${e.message}")
+            }
+        }
+    }
+
+    fun clearAllEvents() {
+        lock.withLock {
+            closeFileWriter()
+            eventsFile.delete()
+            metaFile.delete()
+            eventCount = 0
+            uploadedEventCount = 0
+            lastEventTimestamp = 0
+        }
+    }
+
+    fun close() {
+        lock.withLock {
+            isShutdown = true
+            closeFileWriter()
+        }
+    }
+
+    private fun closeFileWriter() {
+        try {
+            fileWriter?.close()
+        } catch (_: Exception) {
+        } finally {
+            fileWriter = null
+        }
+    }
+
+    fun getLastEventTimestampMs(): Long = lastEventTimestamp
+}

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

@@ -0,0 +1,154 @@
+/**
+ * Utility to detect Android OEM (Original Equipment Manufacturer) and handle
+ * OEM-specific quirks and behaviors.
+ * 
+ * Different OEMs have different behaviors for app lifecycle, especially around
+ * task removal and service callbacks. This utility helps detect and handle
+ * these differences.
+ */
+package com.rejourney.utils
+
+import android.os.Build
+import com.rejourney.core.Logger
+
+object OEMDetector {
+    
+    enum class OEM {
+        SAMSUNG,
+        XIAOMI,
+        HUAWEI,
+        ONEPLUS,
+        OPPO,
+        VIVO,
+        PIXEL,
+        STOCK_ANDROID,
+        UNKNOWN
+    }
+    
+    private val oem: OEM by lazy {
+        detectOEM()
+    }
+    
+    /**
+     * Get the detected OEM.
+     */
+    fun getOEM(): OEM = oem
+    
+    /**
+     * Check if running on Samsung device.
+     * Samsung has known bugs with onTaskRemoved() firing incorrectly.
+     */
+    fun isSamsung(): Boolean = oem == OEM.SAMSUNG
+    
+    /**
+     * Check if running on Pixel or stock Android.
+     * These devices generally have more reliable lifecycle callbacks.
+     */
+    fun isPixelOrStock(): Boolean = oem == OEM.PIXEL || oem == OEM.STOCK_ANDROID
+    
+    /**
+     * Check if running on OEMs with aggressive task killing.
+     * These OEMs may not reliably call onTaskRemoved().
+     */
+    fun hasAggressiveTaskKilling(): Boolean {
+        return oem == OEM.XIAOMI || 
+               oem == OEM.HUAWEI || 
+               oem == OEM.OPPO || 
+               oem == OEM.VIVO
+    }
+    
+    /**
+     * Check if onTaskRemoved() is likely to work reliably on this device.
+     */
+    fun isTaskRemovedReliable(): Boolean {
+        // Pixel/Stock Android: Generally reliable
+        if (isPixelOrStock()) return true
+        
+        // Samsung: Has bugs but sometimes works
+        if (isSamsung()) return true // We'll add validation to filter false positives
+        
+        // Aggressive OEMs: Often don't call onTaskRemoved
+        if (hasAggressiveTaskKilling()) return false
+        
+        // Unknown: Assume it might work
+        return true
+    }
+    
+    /**
+     * Detect the OEM based on manufacturer and brand.
+     */
+    private fun detectOEM(): OEM {
+        val manufacturer = Build.MANUFACTURER.lowercase()
+        val brand = Build.BRAND.lowercase()
+        val model = Build.MODEL.lowercase()
+        
+        return when {
+            // Samsung
+            manufacturer.contains("samsung") || brand.contains("samsung") -> {
+                Logger.debug("OEM detected: Samsung")
+                OEM.SAMSUNG
+            }
+            
+            // Xiaomi (includes Redmi, POCO)
+            manufacturer.contains("xiaomi") || brand.contains("xiaomi") || 
+            brand.contains("redmi") || brand.contains("poco") -> {
+                Logger.debug("OEM detected: Xiaomi")
+                OEM.XIAOMI
+            }
+            
+            // Huawei (includes Honor)
+            manufacturer.contains("huawei") || brand.contains("huawei") || 
+            brand.contains("honor") -> {
+                Logger.debug("OEM detected: Huawei")
+                OEM.HUAWEI
+            }
+            
+            // OnePlus
+            manufacturer.contains("oneplus") || brand.contains("oneplus") -> {
+                Logger.debug("OEM detected: OnePlus")
+                OEM.ONEPLUS
+            }
+            
+            // OPPO
+            manufacturer.contains("oppo") || brand.contains("oppo") -> {
+                Logger.debug("OEM detected: OPPO")
+                OEM.OPPO
+            }
+            
+            // Vivo
+            manufacturer.contains("vivo") || brand.contains("vivo") -> {
+                Logger.debug("OEM detected: Vivo")
+                OEM.VIVO
+            }
+            
+            // Google Pixel
+            manufacturer.contains("google") && (model.contains("pixel") || brand.contains("google")) -> {
+                Logger.debug("OEM detected: Pixel")
+                OEM.PIXEL
+            }
+            
+            // Stock Android (Google devices that aren't Pixel)
+            manufacturer.contains("google") -> {
+                Logger.debug("OEM detected: Stock Android")
+                OEM.STOCK_ANDROID
+            }
+            
+            else -> {
+                Logger.debug("OEM detected: Unknown (manufacturer=$manufacturer, brand=$brand)")
+                OEM.UNKNOWN
+            }
+        }
+    }
+    
+    /**
+     * Get OEM-specific recommendations for app termination detection.
+     */
+    fun getRecommendations(): String {
+        return when (oem) {
+            OEM.SAMSUNG -> "Samsung devices may have onTaskRemoved() fire incorrectly on app launch. Using validation to filter false positives."
+            OEM.XIAOMI, OEM.HUAWEI, OEM.OPPO, OEM.VIVO -> "This OEM has aggressive task killing. onTaskRemoved() may not fire. Relying on ApplicationExitInfo and persistent state checks."
+            OEM.PIXEL, OEM.STOCK_ANDROID -> "Stock Android - onTaskRemoved() should work reliably."
+            else -> "Unknown OEM - using standard detection methods."
+        }
+    }
+}

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

@@ -0,0 +1,235 @@
+/**
+ * Performance timing utility aligned with iOS RJPerfTiming.
+ */
+package com.rejourney.utils
+
+import android.os.Looper
+import android.os.SystemClock
+import com.rejourney.core.Logger
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+import kotlin.math.max
+
+enum class PerfMetric {
+    FRAME,
+    SCREENSHOT,
+    RENDER,
+    PRIVACY_MASK,
+    VIEW_SCAN,
+    VIEW_SERIALIZE,
+    ENCODE,
+    PIXEL_BUFFER,
+    DOWNSCALE,
+    BUFFER_ALLOC,
+    ENCODE_APPEND,
+    UPLOAD
+}
+
+object PerfTiming {
+    private const val PERF_ENABLED = true
+    private const val DUMP_INTERVAL_MS = 5000.0
+    private const val MIN_SAMPLES = 5L
+
+    private val names = arrayOf(
+        "frame_total",
+        "screenshot_ui",
+        "render_draw",
+        "privacy_mask",
+        "view_scan",
+        "view_serialize",
+        "encode_h264",
+        "pixel_buffer",
+        "downscale",
+        "buffer_alloc",
+        "encode_append",
+        "upload_net"
+    )
+
+    private val totals = DoubleArray(PerfMetric.values().size)
+    private val maxes = DoubleArray(PerfMetric.values().size)
+    private val counts = LongArray(PerfMetric.values().size)
+    private var lastDumpTimeNs = 0L
+
+    private val lock = ReentrantLock()
+
+    fun isEnabled(): Boolean = PERF_ENABLED
+
+    fun now(): Long = SystemClock.elapsedRealtimeNanos()
+
+    fun record(metric: PerfMetric, startNs: Long, endNs: Long) {
+        if (!PERF_ENABLED) {
+            return
+        }
+
+        val durationMs = (endNs - startNs).toDouble() / 1_000_000.0
+        val isMain = Looper.getMainLooper().thread == Thread.currentThread()
+        val threadName = if (isMain) "MAIN" else "BG"
+        val name = names[metric.ordinal]
+
+        if (isMain && durationMs > 4.0) {
+            Logger.warning("[RJ-PERF] ⚠️ [$threadName] $name: ${"%.2f".format(durationMs)}ms")
+        } else {
+            Logger.debug("[RJ-PERF] [$threadName] $name: ${"%.2f".format(durationMs)}ms")
+        }
+
+        lock.withLock {
+            counts[metric.ordinal]++
+            totals[metric.ordinal] += durationMs
+            maxes[metric.ordinal] = max(maxes[metric.ordinal], durationMs)
+        }
+    }
+
+    fun dumpIfNeeded() {
+        if (!PERF_ENABLED) {
+            return
+        }
+
+        val now = now()
+        if (lastDumpTimeNs != 0L && msBetween(lastDumpTimeNs, now) < DUMP_INTERVAL_MS) {
+            return
+        }
+
+        lock.withLock {
+            if (lastDumpTimeNs != 0L && msBetween(lastDumpTimeNs, now) < DUMP_INTERVAL_MS) {
+                return
+            }
+
+            var totalSamples = 0L
+            counts.forEach { totalSamples += it }
+            if (totalSamples < MIN_SAMPLES) {
+                return
+            }
+
+            lastDumpTimeNs = now
+
+            val log = StringBuilder("[Rejourney PERF SUMMARY]")
+            for (i in counts.indices) {
+                if (counts[i] > 0) {
+                    val avg = totals[i] / counts[i].toDouble()
+                    log.append(" ")
+                    log.append(names[i])
+                    log.append("=")
+                    log.append(counts[i])
+                    log.append("/")
+                    log.append(String.format("%.1f", avg))
+                    log.append("/")
+                    log.append(String.format("%.1f", maxes[i]))
+                    log.append("ms")
+                }
+            }
+            Logger.debug(log.toString())
+        }
+    }
+
+    fun dump() {
+        if (!PERF_ENABLED) {
+            return
+        }
+
+        lock.withLock {
+            var totalSamples = 0L
+            counts.forEach { totalSamples += it }
+            if (totalSamples == 0L) {
+                Logger.debug("[Rejourney PERF] No samples collected")
+                return
+            }
+
+            val log = StringBuilder()
+            log.append("\n")
+            log.append("╔══════════════════════════════════════════════════════════════╗\n")
+            log.append("║              REJOURNEY SDK PERFORMANCE METRICS (ms)          ║\n")
+            log.append("╠══════════════════════════════════════════════════════════════╣\n")
+            log.append("║  METRIC           │    COUNT │    AVG (ms) │    MAX (ms)    ║\n")
+            log.append("╠══════════════════════════════════════════════════════════════╣\n")
+
+            for (i in counts.indices) {
+                if (counts[i] > 0) {
+                    val avg = totals[i] / counts[i].toDouble()
+                    log.append(
+                        String.format(
+                            "║  %-16s │ %8d │ %10.2f │ %10.2f    ║\n",
+                            names[i],
+                            counts[i],
+                            avg,
+                            maxes[i]
+                        )
+                    )
+                }
+            }
+
+            log.append("╚══════════════════════════════════════════════════════════════╝")
+            lastDumpTimeNs = now()
+            Logger.debug(log.toString())
+        }
+    }
+
+    fun reset() {
+        if (!PERF_ENABLED) {
+            return
+        }
+
+        lock.withLock {
+            for (i in counts.indices) {
+                totals[i] = 0.0
+                maxes[i] = 0.0
+                counts[i] = 0
+            }
+            lastDumpTimeNs = 0L
+        }
+        Logger.debug("[Rejourney PERF] Metrics reset")
+    }
+
+    fun snapshot(): Map<String, Map<String, Number>> {
+        if (!PERF_ENABLED) {
+            return emptyMap()
+        }
+
+        return lock.withLock {
+            val result = mutableMapOf<String, Map<String, Number>>()
+            for (i in counts.indices) {
+                if (counts[i] > 0) {
+                    val avg = totals[i] / counts[i].toDouble()
+                    result[names[i]] = mapOf(
+                        "count" to counts[i],
+                        "avg_us" to avg,
+                        "max_us" to maxes[i],
+                        "total_us" to totals[i]
+                    )
+                }
+            }
+            result
+        }
+    }
+
+    fun nameForMetric(metric: PerfMetric): String {
+        return names.getOrElse(metric.ordinal) { "unknown" }
+    }
+
+    fun <T> time(metric: PerfMetric, block: () -> T): T {
+        if (!PERF_ENABLED) {
+            return block()
+        }
+        val start = now()
+        return try {
+            block()
+        } finally {
+            record(metric, start, now())
+        }
+    }
+
+    fun <T> measure(label: String, block: () -> T): T {
+        val start = now()
+        return try {
+            block()
+        } finally {
+            val end = now()
+            val durationUs = (end - start) / 1000
+            val durationMs = durationUs / 1000.0
+            Logger.debug("[PerfTiming] $label: ${durationUs}us (${String.format("%.3f", durationMs)}ms)")
+        }
+    }
+
+    private fun msBetween(startNs: Long, endNs: Long): Double {
+        return (endNs - startNs).toDouble() / 1_000_000.0
+    }
+}