@rejourneyco/react-native 1.0.0

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

@@ -0,0 +1,286 @@
+/**
+ * View hierarchy serializer aligned with iOS RJViewSerializer.
+ */
+package com.rejourney.capture
+
+import android.graphics.Color
+import android.graphics.drawable.ColorDrawable
+import android.os.SystemClock
+import android.view.View
+import android.view.ViewGroup
+import android.view.Window
+import android.widget.Button
+import android.widget.CompoundButton
+import android.widget.EditText
+import android.widget.HorizontalScrollView
+import android.widget.ImageView
+import android.widget.ScrollView
+import android.widget.TextView
+import androidx.core.widget.NestedScrollView
+import androidx.recyclerview.widget.RecyclerView
+import com.rejourney.privacy.PrivacyMask
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.math.min
+
+class ViewSerializer(private val density: Float) {
+    var enabled: Boolean = true
+    var maxDepth: Int = 10
+    var includeVisualProperties: Boolean = true
+    var includeTextContent: Boolean = true
+
+    private val imageViewClass = ImageView::class.java
+    private val buttonClass = Button::class.java
+    private val scrollViewClass = ScrollView::class.java
+    private val textFieldClass = EditText::class.java
+    private val textViewClass = TextView::class.java
+
+    fun serializeWindow(
+        window: Window,
+        scanResult: ViewHierarchyScanResult? = null,
+        timestamp: Long = System.currentTimeMillis()
+    ): Map<String, Any?> {
+        if (!enabled) return emptyMap()
+
+        val rootView = window.decorView ?: return emptyMap()
+        val width = sanitizeFloat(rootView.width / density)
+        val height = sanitizeFloat(rootView.height / density)
+        val scale = sanitizeFloat(density)
+
+        val startTime = SystemClock.elapsedRealtimeNanos()
+        val rootNode = serializeViewInternal(rootView, 0, startTime)
+
+        val result = mutableMapOf<String, Any?>(
+            "timestamp" to timestamp,
+            "screen" to mapOf(
+                "width" to width,
+                "height" to height,
+                "scale" to scale
+            ),
+            "root" to rootNode
+        )
+
+        scanResult?.layoutSignature?.let { result["layoutSignature"] = it }
+        return result
+    }
+
+    fun serializeView(view: View): Map<String, Any?> {
+        if (!enabled) return emptyMap()
+        val startTime = SystemClock.elapsedRealtimeNanos()
+        return serializeViewInternal(view, 0, startTime)
+    }
+
+    private fun serializeViewInternal(view: View, depth: Int, startTime: Long): Map<String, Any?> {
+        if (depth > maxDepth) return emptyMap()
+
+        if (SystemClock.elapsedRealtimeNanos() - startTime > VIEW_SERIALIZATION_BUDGET_NS) {
+            return mapOf(
+                "type" to classNameFor(view.javaClass),
+                "bailout" to true
+            )
+        }
+
+        if (depth > 0 && (!view.isShown || view.alpha <= 0.01f)) return emptyMap()
+        if (view.width <= 0 || view.height <= 0) return emptyMap()
+
+        val node = mutableMapOf<String, Any?>()
+
+        node["type"] = classNameFor(view.javaClass)
+
+        val frame = mapOf(
+            "x" to sanitizeFloat(view.x / density),
+            "y" to sanitizeFloat(view.y / density),
+            "w" to sanitizeFloat(view.width / density),
+            "h" to sanitizeFloat(view.height / density)
+        )
+        node["frame"] = frame
+
+        if (view.visibility != View.VISIBLE) {
+            node["hidden"] = true
+        }
+        if (view.alpha < 1.0f) {
+            node["alpha"] = view.alpha
+        }
+
+        val nativeId = view.getTag(com.facebook.react.R.id.view_tag_native_id)
+        if (nativeId is String && nativeId.isNotEmpty()) {
+            node["testID"] = nativeId
+        }
+        val label = view.contentDescription?.toString()
+        if (!label.isNullOrEmpty()) {
+            node["label"] = label
+        }
+
+        if (PrivacyMask.isSensitiveView(view)) {
+            node["masked"] = true
+        }
+
+        if (includeVisualProperties) {
+            val bgColor = extractBackgroundColor(view)
+            if (bgColor != null && Color.alpha(bgColor) > 0) {
+                node["bg"] = colorToHex(bgColor)
+            }
+        }
+
+        if (includeTextContent) {
+            val text = extractTextFromView(view)
+            if (!text.isNullOrEmpty()) {
+                node["text"] = maskText(text)
+                node["textLength"] = text.length
+            }
+        }
+
+        if (imageViewClass.isInstance(view)) {
+            node["hasImage"] = true
+            val imageLabel = view.contentDescription?.toString()
+            if (!imageLabel.isNullOrEmpty()) {
+                node["imageLabel"] = imageLabel
+            }
+        }
+
+        if (isInteractiveView(view)) {
+            node["interactive"] = true
+
+            if (buttonClass.isInstance(view)) {
+                val buttonText = (view as? Button)?.text?.toString()
+                if (!buttonText.isNullOrEmpty()) {
+                    node["buttonTitle"] = buttonText
+                }
+                node["enabled"] = view.isEnabled
+            }
+
+            if (view is CompoundButton) {
+                node["switchOn"] = view.isChecked
+            }
+        }
+
+        if (scrollViewClass.isInstance(view) || view is HorizontalScrollView || view is NestedScrollView || view is RecyclerView) {
+            val (offsetX, offsetY, contentWidth, contentHeight) = scrollMetricsFor(view)
+            node["contentOffset"] = mapOf(
+                "x" to sanitizeFloat(offsetX / density),
+                "y" to sanitizeFloat(offsetY / density)
+            )
+            node["contentSize"] = mapOf(
+                "w" to sanitizeFloat(contentWidth / density),
+                "h" to sanitizeFloat(contentHeight / density)
+            )
+        }
+
+        if (view is ViewGroup) {
+            val children = mutableListOf<Map<String, Any?>>()
+            val parentWidth = view.width
+            val parentHeight = view.height
+            for (i in view.childCount - 1 downTo 0) {
+                val child = view.getChildAt(i)
+                if (!child.isShown || child.alpha <= 0.01f) continue
+                if (child.width <= 0 || child.height <= 0) continue
+
+                val childNode = serializeViewInternal(child, depth + 1, startTime)
+                if (childNode.isNotEmpty()) {
+                    children.add(0, childNode)
+                }
+
+                if (child.isOpaque && child.alpha >= 1.0f &&
+                    child.left == 0 && child.top == 0 &&
+                    child.width == parentWidth && child.height == parentHeight
+                ) {
+                    break
+                }
+            }
+
+            if (children.isNotEmpty()) {
+                node["children"] = children
+            }
+        }
+
+        return node
+    }
+
+    private fun isInteractiveView(view: View): Boolean {
+        if (view.isClickable || view.isLongClickable) return true
+        if (textFieldClass.isInstance(view) || textViewClass.isInstance(view)) return true
+        return view.hasOnClickListeners() || view.isFocusable
+    }
+
+    private fun extractTextFromView(view: View): String? {
+        return when (view) {
+            is TextView -> view.text?.toString()
+            is Button -> view.text?.toString()
+            else -> null
+        }
+    }
+
+    private fun maskText(text: String): String {
+        if (text.isEmpty()) return ""
+        val maskLength = min(text.length, 12)
+        return "*".repeat(maskLength)
+    }
+
+    private fun extractBackgroundColor(view: View): Int? {
+        val background = view.background ?: return null
+        return when (background) {
+            is ColorDrawable -> background.color
+            else -> null
+        }
+    }
+
+    private fun colorToHex(color: Int): String {
+        val r = Color.red(color)
+        val g = Color.green(color)
+        val b = Color.blue(color)
+        return String.format("#%02X%02X%02X", r, g, b)
+    }
+
+    private fun scrollMetricsFor(view: View): ScrollMetrics {
+        return when (view) {
+            is RecyclerView -> ScrollMetrics(
+                view.computeHorizontalScrollOffset(),
+                view.computeVerticalScrollOffset(),
+                view.computeHorizontalScrollRange(),
+                view.computeVerticalScrollRange()
+            )
+            is ScrollView -> ScrollMetrics(
+                view.scrollX,
+                view.scrollY,
+                view.getChildAt(0)?.width ?: view.width,
+                view.getChildAt(0)?.height ?: view.height
+            )
+            is HorizontalScrollView -> ScrollMetrics(
+                view.scrollX,
+                view.scrollY,
+                view.getChildAt(0)?.width ?: view.width,
+                view.getChildAt(0)?.height ?: view.height
+            )
+            is NestedScrollView -> ScrollMetrics(
+                view.scrollX,
+                view.scrollY,
+                view.getChildAt(0)?.width ?: view.width,
+                view.getChildAt(0)?.height ?: view.height
+            )
+            else -> ScrollMetrics(view.scrollX, view.scrollY, view.width, view.height)
+        }
+    }
+
+    private fun classNameFor(cls: Class<*>): String {
+        return classNameCache[cls] ?: run {
+            val name = cls.simpleName
+            classNameCache[cls] = name
+            name
+        }
+    }
+
+    private fun sanitizeFloat(value: Float): Float {
+        return if (value.isNaN() || value.isInfinite()) 0f else value
+    }
+
+    private data class ScrollMetrics(
+        val offsetX: Int,
+        val offsetY: Int,
+        val contentWidth: Int,
+        val contentHeight: Int
+    )
+
+    companion object {
+        private const val VIEW_SERIALIZATION_BUDGET_NS = 10_000_000L
+        private val classNameCache = ConcurrentHashMap<Class<*>, String>()
+    }
+}

package/android/src/main/java/com/rejourney/core/Constants.kt

@@ -0,0 +1,117 @@
+/**
+ * SDK-wide constants and configuration defaults.
+ * Ported from iOS RJConstants.h/m
+ */
+package com.rejourney.core
+
+object Constants {
+    // SDK Version
+    const val SDK_VERSION = "1.0.0"
+
+    // Video Capture Configuration (H.264 Segment Mode)
+    // These match iOS RJCaptureEngine defaults for performance
+    
+    /** Default capture scale factor (0.35 = 35% of original size) - matches iOS */
+    const val DEFAULT_CAPTURE_SCALE = 0.35f
+
+    /** Target video bitrate in bits per second (1.5 Mbps) - matches iOS */
+    const val DEFAULT_VIDEO_BITRATE = 1_500_000
+
+    /** Maximum video dimension in pixels (longest edge) - matches iOS */
+    const val MAX_VIDEO_DIMENSION = 1920
+
+    /** Target frames per second for video capture (15 FPS) - matches iOS */
+    const val DEFAULT_VIDEO_FPS = 15
+
+    /** Number of frames per segment before auto-rotation (60 frames = 60 seconds at 1 FPS) */
+    const val DEFAULT_FRAMES_PER_SEGMENT = 60
+
+    /** Keyframe interval in seconds (10s for better compression) - matches iOS */
+    const val DEFAULT_KEYFRAME_INTERVAL = 10
+
+    /** Minimum frame interval in seconds (1/15 ~= 0.0667) */
+    const val DEFAULT_MIN_FRAME_INTERVAL = 0.0667
+
+    /** Maximum frames allowed per minute (15 FPS * 60s) */
+    const val DEFAULT_MAX_FRAMES_PER_MINUTE = 900
+
+    /** Segment duration in seconds (for planning purposes) */
+    const val DEFAULT_SEGMENT_DURATION_SECONDS = 60
+
+    // Motion Event Configuration
+    /** Minimum interval between motion events (0.016 = 60 FPS motion capture) */
+    const val DEFAULT_MOTION_EVENT_INTERVAL = 0.016
+    
+    /** Minimum velocity to record scroll motion (points/second) */
+    const val MOTION_VELOCITY_THRESHOLD = 10f
+    
+    /** Scroll distance threshold for motion events (points) */
+    const val DEFAULT_SCROLL_THRESHOLD = 5f
+    
+    /** Time after last scroll event to consider scroll ended (seconds) */
+    const val SCROLL_END_DELAY = 0.15
+
+    // Memory Thresholds
+    /** Memory warning threshold in bytes (100MB) */
+    const val MEMORY_WARNING_THRESHOLD_BYTES = 100L * 1024 * 1024
+    
+    /** Maximum frame data bytes to keep in memory */
+    // Frames are sparse but can be large (data URIs). Too low causes aggressive eviction
+    // before the upload timer drains, especially during crashes/offline.
+    const val MAX_FRAME_BYTES_IN_MEMORY = 4L * 1024 * 1024
+    
+    /** Default maximum frames to keep in memory */
+    const val DEFAULT_MAX_FRAMES_IN_MEMORY = 20
+
+    // Performance Thresholds
+    /** Battery level threshold for low-power mode (15%) */
+    const val LOW_BATTERY_THRESHOLD = 0.15f
+    
+    /** Maximum consecutive captures before cooldown */
+    const val MAX_CONSECUTIVE_CAPTURES = 5
+    
+    /** Cooldown duration after max consecutive captures (seconds) */
+    const val CAPTURE_COOLDOWN_SECONDS = 1.0
+
+    // Upload Configuration
+    /** Batch upload interval in seconds */
+    const val BATCH_UPLOAD_INTERVAL = 5.0
+    
+    /** Initial upload delay for short sessions (seconds) */
+    const val INITIAL_UPLOAD_DELAY = 1.0
+    
+    /** Network request timeout (seconds) */
+    const val NETWORK_REQUEST_TIMEOUT = 60.0
+    
+    /** Network resource timeout (seconds) */
+    const val NETWORK_RESOURCE_TIMEOUT = 120.0
+
+    // Session Configuration
+    /** Background duration threshold for new session (seconds) - 60 seconds matches iOS */
+    const val BACKGROUND_SESSION_TIMEOUT = 60.0
+
+    // Gesture Detection
+    /** Maximum time between taps for double-tap detection (milliseconds) */
+    const val DOUBLE_TAP_MAX_INTERVAL = 300.0
+    
+    /** Maximum distance between taps for double-tap detection (points) */
+    const val DOUBLE_TAP_MAX_DISTANCE = 50f
+    
+    /** Minimum duration for long press detection (milliseconds) */
+    const val LONG_PRESS_MIN_DURATION = 500.0
+    
+    /** Minimum distance for swipe gesture detection (points) */
+    const val SWIPE_MIN_DISTANCE = 50f
+    
+    /** Force touch threshold (normalized force value) */
+    const val FORCE_TOUCH_THRESHOLD = 2.0f
+
+    /** Minimum distance for pinch gesture detection (points) */
+    const val PINCH_MIN_DISTANCE = 30f
+    
+    /** Minimum distance change percentage for pinch detection */
+    const val PINCH_MIN_CHANGE_PERCENT = 0.2f
+    
+    /** Minimum rotation angle for rotation gesture detection (degrees) */
+    const val ROTATION_MIN_ANGLE = 15f
+}

package/android/src/main/java/com/rejourney/core/Logger.kt

@@ -0,0 +1,93 @@
+package com.rejourney.core
+
+import android.util.Log
+import com.rejourney.BuildConfig
+
+enum class LogLevel(val priority: Int) {
+    DEBUG(0),
+    INFO(1),
+    WARNING(2),
+    ERROR(3),
+    SILENT(4)
+}
+
+object Logger {
+    private const val TAG = "Rejourney"
+    private var debugMode = false
+
+    var minimumLogLevel: LogLevel = if (BuildConfig.DEBUG) LogLevel.ERROR else LogLevel.SILENT
+        private set
+
+    fun setLogLevel(level: LogLevel) {
+        minimumLogLevel = level
+    }
+
+    fun setDebugMode(enabled: Boolean) {
+        debugMode = enabled
+        minimumLogLevel = if (enabled) {
+            LogLevel.DEBUG
+        } else if (BuildConfig.DEBUG) {
+            LogLevel.ERROR
+        } else {
+            LogLevel.SILENT
+        }
+    }
+
+    fun debug(message: String) {
+        if (minimumLogLevel.priority <= LogLevel.DEBUG.priority) {
+            Log.d(TAG, message)
+        }
+    }
+
+    fun info(message: String) {
+        if (minimumLogLevel.priority <= LogLevel.INFO.priority) {
+            Log.i(TAG, message)
+        }
+    }
+
+    fun warning(message: String) {
+        if (minimumLogLevel.priority <= LogLevel.WARNING.priority) {
+            Log.w(TAG, message)
+        }
+    }
+
+    fun error(message: String, throwable: Throwable? = null) {
+        if (minimumLogLevel.priority <= LogLevel.ERROR.priority) {
+            if (throwable != null) {
+                Log.e(TAG, message, throwable)
+            } else {
+                Log.e(TAG, message)
+            }
+        }
+    }
+    
+    fun logInitSuccess(version: String) {
+        if (debugMode) {
+            info("✓ SDK initialized (v$version)")
+        }
+    }
+
+    fun logInitFailure(reason: String) {
+        error("✗ Initialization failed: $reason")
+    }
+
+    fun logSessionStart(sessionId: String) {
+        if (debugMode) {
+            info("Session started: $sessionId")
+        }
+    }
+
+    fun logSessionEnd(sessionId: String) {
+        if (debugMode) {
+            info("Session ended: $sessionId")
+        }
+    }
+
+    fun logArchitectureInfo(isNewArch: Boolean, architectureType: String) {
+        if (minimumLogLevel.priority <= LogLevel.DEBUG.priority) {
+            debug("React Native Architecture: $architectureType")
+            debug("New Architecture Enabled: ${if (isNewArch) "YES" else "NO"}")
+            debug("Rejourney SDK Version: ${Constants.SDK_VERSION}")
+        }
+    }
+}

package/android/src/main/java/com/rejourney/core/Types.kt

@@ -0,0 +1,124 @@
+/**
+ * Common type definitions used throughout the SDK.
+ * Ported from iOS RJTypes.h/m
+ */
+package com.rejourney.core
+
+/**
+ * Represents the importance level of a capture event.
+ * Higher importance events are less likely to be skipped during throttling.
+ */
+enum class CaptureImportance(val value: Int) {
+    /** Low importance - can be freely skipped (e.g., heartbeat) */
+    LOW(0),
+    
+    /** Medium importance - skip only under heavy load (e.g., tap gestures) */
+    MEDIUM(1),
+    
+    /** High importance - rarely skip (e.g., scroll events) */
+    HIGH(2),
+    
+    /** Critical importance - never skip (e.g., navigation, app lifecycle) */
+    CRITICAL(3)
+}
+
+/**
+ * Represents the current performance level of the capture engine.
+ * The engine adjusts its behavior based on system conditions.
+ */
+enum class PerformanceLevel(val value: Int) {
+    /** Normal operation - full capture rate */
+    NORMAL(0),
+    
+    /** Reduced rate due to low battery or thermal throttling */
+    REDUCED(1),
+    
+    /** Minimal captures due to memory pressure */
+    MINIMAL(2),
+    
+    /** All non-critical captures paused */
+    PAUSED(3)
+}
+
+/**
+ * Represents recognized gesture types.
+ */
+object GestureType {
+    const val TAP = "tap"
+    const val DOUBLE_TAP = "double_tap"
+    const val LONG_PRESS = "long_press"
+    const val FORCE_TOUCH = "force_touch"
+    const val SWIPE_LEFT = "swipe_left"
+    const val SWIPE_RIGHT = "swipe_right"
+    const val SWIPE_UP = "swipe_up"
+    const val SWIPE_DOWN = "swipe_down"
+    const val SCROLL_UP = "scroll_up"
+    const val SCROLL_DOWN = "scroll_down"
+    const val PINCH_IN = "pinch_in"
+    const val PINCH_OUT = "pinch_out"
+    const val ROTATE_CW = "rotate_cw"
+    const val ROTATE_CCW = "rotate_ccw"
+    const val PAN_UP = "pan_up"
+    const val PAN_DOWN = "pan_down"
+    const val PAN_LEFT = "pan_left"
+    const val PAN_RIGHT = "pan_right"
+    const val TWO_FINGER_TAP = "two_finger_tap"
+    const val THREE_FINGER_GESTURE = "three_finger_gesture"
+    const val MULTI_TOUCH = "multi_touch"
+    const val KEYBOARD_TAP = "keyboard_tap"
+}
+
+/**
+ * Represents session event types for logging.
+ */
+object EventType {
+    const val SESSION_START = "session_start"
+    const val SESSION_END = "session_end"
+    const val SESSION_TIMEOUT = "session_timeout"
+    const val NAVIGATION = "navigation"
+    const val GESTURE = "gesture"
+    const val VISUAL_CHANGE = "visual_change"
+    const val KEYBOARD_SHOW = "keyboard_show"
+    const val KEYBOARD_HIDE = "keyboard_hide"
+    const val KEYBOARD_TYPING = "keyboard_typing"
+    const val APP_BACKGROUND = "app_background"
+    const val APP_FOREGROUND = "app_foreground"
+    const val APP_TERMINATED = "app_terminated"
+    const val EXTERNAL_URL_OPENED = "external_url_opened"
+    const val OAUTH_STARTED = "oauth_started"
+    const val OAUTH_COMPLETED = "oauth_completed"
+    const val OAUTH_RETURNED = "oauth_returned"
+}
+
+/**
+ * Result type for session operations
+ */
+data class SessionResult(
+    val success: Boolean,
+    val sessionId: String = "",
+    val error: String? = null,
+    val uploadSuccess: Boolean? = null,
+    val warning: String? = null
+)
+
+/**
+ * SDK telemetry metrics for observability
+ */
+data class SDKMetrics(
+    val uploadSuccessCount: Int = 0,
+    val uploadFailureCount: Int = 0,
+    val retryAttemptCount: Int = 0,
+    val circuitBreakerOpenCount: Int = 0,
+    val memoryEvictionCount: Int = 0,
+    val offlinePersistCount: Int = 0,
+    val sessionStartCount: Int = 0,
+    val crashCount: Int = 0,
+    val anrCount: Int = 0,
+    val uploadSuccessRate: Float = 0f,
+    val avgUploadDurationMs: Long = 0,
+    val currentQueueDepth: Int = 0,
+    val lastUploadTime: Long? = null,
+    val lastRetryTime: Long? = null,
+    val totalBytesUploaded: Long = 0,
+    val totalBytesEvicted: Long = 0
+)