sitepong 0.2.3 → 0.2.5

package/android/build.gradle

@@ -0,0 +1,39 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+// One Android library for the whole SitePong SDK. It hosts every native Expo
+// module that used to ship as its own package — screen recorder + device id.
+// The Kotlin sources keep their original package names
+// (com.sitepong.screenrecorder.*, com.sitepong.deviceid.*); the gradle
+// `namespace` below is just the library's own R/manifest package and is
+// independent of them.
+group = 'com.sitepong.sdk'
+version = '0.2.3'
+
+android {
+  namespace "com.sitepong.sdk"
+  compileSdkVersion safeExtGet("compileSdkVersion", 34)
+
+  defaultConfig {
+    minSdkVersion safeExtGet("minSdkVersion", 26)
+    targetSdkVersion safeExtGet("targetSdkVersion", 34)
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = "17"
+  }
+}
+
+dependencies {
+  implementation project(':expo-modules-core')
+  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${safeExtGet('kotlinVersion', '1.9.0')}"
+}
+
+def safeExtGet(prop, fallback) {
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}

package/android/src/main/java/com/sitepong/deviceid/DeviceIdHelper.kt

@@ -0,0 +1,45 @@
+package com.sitepong.deviceid
+
+import android.content.Context
+import android.provider.Settings
+import java.security.MessageDigest
+import java.util.UUID
+
+/**
+ * Manages a persistent device identifier on Android.
+ *
+ * Combines two signals:
+ * - ANDROID_ID: Stable per app signing key since Android 8. Survives reinstalls.
+ * - SharedPreferences UUID: Persists via Auto Backup (if user has same Google account).
+ *
+ * The final device ID is SHA-256(androidId + storedUuid) for a composite stable ID.
+ */
+object DeviceIdHelper {
+  private const val PREFS_NAME = "sitepong_device"
+  private const val KEY_UUID = "persistent_uuid"
+
+  fun getOrCreateDeviceId(context: Context): String {
+    val androidId = getAndroidId(context)
+    val storedUuid = getOrCreateUuid(context)
+    return sha256("$androidId$storedUuid")
+  }
+
+  fun getAndroidId(context: Context): String {
+    return Settings.Secure.getString(context.contentResolver, Settings.Secure.ANDROID_ID) ?: ""
+  }
+
+  private fun getOrCreateUuid(context: Context): String {
+    val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+    val existing = prefs.getString(KEY_UUID, null)
+    if (existing != null) return existing
+
+    val uuid = UUID.randomUUID().toString()
+    prefs.edit().putString(KEY_UUID, uuid).apply()
+    return uuid
+  }
+
+  private fun sha256(input: String): String {
+    val bytes = MessageDigest.getInstance("SHA-256").digest(input.toByteArray())
+    return bytes.joinToString("") { "%02x".format(it) }
+  }
+}

package/android/src/main/java/com/sitepong/deviceid/DeviceIdModule.kt

@@ -0,0 +1,45 @@
+package com.sitepong.deviceid
+
+import android.os.Build
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+
+class DeviceIdModule : Module() {
+  override fun definition() = ModuleDefinition {
+    Name("SitePongDeviceId")
+
+    AsyncFunction("getDeviceId") {
+      val context = appContext.reactContext ?: throw Exception("React context not available")
+      DeviceIdHelper.getOrCreateDeviceId(context)
+    }
+
+    AsyncFunction("getDeviceSignals") {
+      val context = appContext.reactContext ?: throw Exception("React context not available")
+      val deviceId = DeviceIdHelper.getOrCreateDeviceId(context)
+      val androidId = DeviceIdHelper.getAndroidId(context)
+      val density = context.resources.displayMetrics.density
+
+      mapOf(
+        "deviceId" to deviceId,
+        "platform" to "android",
+        "osVersion" to Build.VERSION.RELEASE,
+        "model" to Build.MODEL,
+        "manufacturer" to Build.MANUFACTURER,
+        "isEmulator" to isEmulator(),
+        "screenScale" to density.toDouble(),
+        "androidId" to androidId
+      )
+    }
+  }
+
+  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)
+  }
+}

package/android/src/main/java/com/sitepong/screenrecorder/ChunkUploader.kt

@@ -0,0 +1,78 @@
+package com.sitepong.screenrecorder
+
+import java.io.OutputStream
+import java.net.HttpURLConnection
+import java.net.URL
+import java.util.concurrent.Executors
+import java.util.concurrent.locks.ReentrantLock
+
+class ChunkUploader(
+  private val endpoint: String,
+  private val apiKey: String,
+  private val sessionId: String
+) {
+  private var chunkSequence = 0
+  private val buffer = mutableListOf<ByteArray>()
+  private val lock = ReentrantLock()
+  private val executor = Executors.newSingleThreadExecutor()
+
+  fun bufferNALUnit(data: ByteArray, isKeyframe: Boolean) {
+    lock.lock()
+    try {
+      buffer.add(data)
+    } finally {
+      lock.unlock()
+    }
+  }
+
+  fun flushBuffer() {
+    lock.lock()
+    val dataChunks: List<ByteArray>
+    try {
+      if (buffer.isEmpty()) return
+      dataChunks = buffer.toList()
+      buffer.clear()
+    } finally {
+      lock.unlock()
+    }
+
+    val combined = dataChunks.fold(ByteArray(0)) { acc, bytes -> acc + bytes }
+    val seq = chunkSequence++
+
+    executor.submit {
+      uploadWithRetry(combined, seq)
+    }
+  }
+
+  private fun uploadWithRetry(data: ByteArray, sequence: Int) {
+    for (attempt in 0..1) {
+      try {
+        val url = URL("$endpoint/api/replays/video")
+        val conn = url.openConnection() as HttpURLConnection
+        conn.requestMethod = "POST"
+        conn.setRequestProperty("Content-Type", "application/octet-stream")
+        conn.setRequestProperty("X-API-Key", apiKey)
+        conn.setRequestProperty("X-Session-ID", sessionId)
+        conn.setRequestProperty("X-Chunk-Sequence", sequence.toString())
+        conn.setRequestProperty("X-Trigger", "error")
+        conn.connectTimeout = 10_000
+        conn.readTimeout = 10_000
+        conn.doOutput = true
+
+        conn.outputStream.use { out: OutputStream ->
+          out.write(data)
+        }
+
+        val responseCode = conn.responseCode
+        conn.disconnect()
+
+        if (responseCode in 200..299) return
+        if (attempt == 0) continue // retry
+      } catch (e: Exception) {
+        if (attempt == 1) {
+          // Drop the chunk — don't block recording
+        }
+      }
+    }
+  }
+}

package/android/src/main/java/com/sitepong/screenrecorder/H264Encoder.kt

@@ -0,0 +1,163 @@
+package com.sitepong.screenrecorder
+
+import android.app.Activity
+import android.graphics.Bitmap
+import android.media.MediaCodec
+import android.media.MediaCodecInfo
+import android.media.MediaFormat
+import android.os.Bundle
+import java.nio.ByteBuffer
+import java.util.concurrent.ConcurrentLinkedQueue
+import java.util.concurrent.locks.ReentrantLock
+
+class H264Encoder(
+  private val bitrate: Int,
+  private val bufferDurationMs: Int,
+  private val onEncodedChunk: (ByteArray, Boolean) -> Unit
+) {
+  private var codec: MediaCodec? = null
+  private var inputSurface: android.view.Surface? = null
+  private var width = 0
+  private var height = 0
+  private var started = false
+  private var frameCount = 0L
+  private val startTimeNs = System.nanoTime()
+
+  data class NALEntry(val data: ByteArray, val isKeyframe: Boolean, val timestampMs: Long)
+
+  private val nalBuffer = ConcurrentLinkedQueue<NALEntry>()
+  private val bufferLock = ReentrantLock()
+
+  fun start(activity: Activity) {
+    val decorView = activity.window?.decorView ?: return
+    width = decorView.width
+    height = decorView.height
+    if (width <= 0 || height <= 0) return
+
+    // Ensure dimensions are even (required by MediaCodec)
+    width = width and 0x7FFFFFFE.toInt()
+    height = height and 0x7FFFFFFE.toInt()
+
+    val format = MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, width, height).apply {
+      setInteger(MediaFormat.KEY_BIT_RATE, bitrate)
+      setInteger(MediaFormat.KEY_FRAME_RATE, 3)
+      setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 5)
+      setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface)
+      setInteger(MediaFormat.KEY_PROFILE, MediaCodecInfo.CodecProfileLevel.AVCProfileBaseline)
+    }
+
+    codec = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_VIDEO_AVC)
+    codec?.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
+
+    codec?.setCallback(object : MediaCodec.Callback() {
+      override fun onInputBufferAvailable(codec: MediaCodec, index: Int) {
+        // Using surface input mode — this won't be called
+      }
+
+      override fun onOutputBufferAvailable(codec: MediaCodec, index: Int, info: MediaCodec.BufferInfo) {
+        val buffer = codec.getOutputBuffer(index) ?: return
+        if (info.size > 0 && info.flags and MediaCodec.BUFFER_FLAG_CODEC_CONFIG == 0) {
+          val data = ByteArray(info.size)
+          buffer.get(data)
+          val isKeyframe = info.flags and MediaCodec.BUFFER_FLAG_KEY_FRAME != 0
+          val timestampMs = System.currentTimeMillis()
+
+          val entry = NALEntry(data, isKeyframe, timestampMs)
+          nalBuffer.add(entry)
+          trimBuffer()
+
+          onEncodedChunk(data, isKeyframe)
+        }
+        codec.releaseOutputBuffer(index, false)
+      }
+
+      override fun onError(codec: MediaCodec, e: MediaCodec.CodecException) {
+        // Log but don't crash
+      }
+
+      override fun onOutputFormatChanged(codec: MediaCodec, format: MediaFormat) {
+        // SPS/PPS available in format — extract for first chunk
+        val sps = format.getByteBuffer("csd-0")
+        val pps = format.getByteBuffer("csd-1")
+        if (sps != null && pps != null) {
+          val spsData = ByteArray(sps.remaining())
+          sps.get(spsData)
+          val ppsData = ByteArray(pps.remaining())
+          pps.get(ppsData)
+          val combined = spsData + ppsData
+          nalBuffer.add(NALEntry(combined, true, System.currentTimeMillis()))
+        }
+      }
+    })
+
+    inputSurface = codec?.createInputSurface()
+    codec?.start()
+    started = true
+  }
+
+  fun encode(bitmap: Bitmap) {
+    if (!started) return
+    val surface = inputSurface ?: return
+
+    try {
+      val canvas = surface.lockHardwareCanvas()
+      canvas.drawBitmap(bitmap, 0f, 0f, null)
+      surface.unlockCanvasAndPost(canvas)
+    } catch (e: Exception) {
+      // Skip frame on error
+    }
+  }
+
+  fun flushPendingFrames() {
+    // Request a sync frame to ensure clean output
+    if (started) {
+      try {
+        val params = Bundle()
+        params.putInt(MediaCodec.PARAMETER_KEY_REQUEST_SYNC_FRAME, 0)
+        codec?.setParameters(params)
+      } catch (e: Exception) {
+        // Ignore
+      }
+    }
+  }
+
+  fun stop() {
+    started = false
+    try {
+      codec?.stop()
+      codec?.release()
+    } catch (e: Exception) {
+      // Ignore
+    }
+    codec = null
+    inputSurface?.release()
+    inputSurface = null
+    nalBuffer.clear()
+  }
+
+  fun drainBuffer(): ByteArray {
+    bufferLock.lock()
+    try {
+      var combined = ByteArray(0)
+      while (nalBuffer.isNotEmpty()) {
+        val entry = nalBuffer.poll() ?: break
+        combined += entry.data
+      }
+      return combined
+    } finally {
+      bufferLock.unlock()
+    }
+  }
+
+  private fun trimBuffer() {
+    val cutoffMs = System.currentTimeMillis() - bufferDurationMs
+    while (nalBuffer.isNotEmpty()) {
+      val head = nalBuffer.peek() ?: break
+      if (head.timestampMs < cutoffMs) {
+        nalBuffer.poll()
+      } else {
+        break
+      }
+    }
+  }
+}

package/android/src/main/java/com/sitepong/screenrecorder/ScreenCapture.kt

@@ -0,0 +1,103 @@
+package com.sitepong.screenrecorder
+
+import android.app.Activity
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Rect
+import android.os.Handler
+import android.os.Looper
+import android.view.PixelCopy
+import android.view.View
+
+class ScreenCapture(
+  private val activity: Activity,
+  private val fps: Int,
+  private val sensitiveViewManager: SensitiveViewManager,
+  private val onFrame: (Bitmap) -> Unit
+) {
+  private val handler = Handler(Looper.getMainLooper())
+  private var running = false
+  private val intervalMs = (1000L / fps.coerceIn(1, 10))
+
+  private val captureRunnable = object : Runnable {
+    override fun run() {
+      if (!running) return
+      captureFrame()
+      handler.postDelayed(this, intervalMs)
+    }
+  }
+
+  fun start() {
+    if (running) return
+    running = true
+    handler.postDelayed(captureRunnable, intervalMs)
+  }
+
+  fun stop() {
+    running = false
+    handler.removeCallbacks(captureRunnable)
+  }
+
+  private fun captureFrame() {
+    val window = activity.window ?: return
+    val decorView = window.decorView
+    val width = decorView.width
+    val height = decorView.height
+    if (width <= 0 || height <= 0) return
+
+    val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
+
+    // Try PixelCopy (API 26+)
+    try {
+      val copyHandler = Handler(Looper.getMainLooper())
+      PixelCopy.request(window, bitmap, { result ->
+        if (result == PixelCopy.SUCCESS) {
+          // Apply sensitive view masks
+          applySensitiveMasks(bitmap, decorView)
+          onFrame(bitmap)
+        } else {
+          // Fallback to canvas draw
+          captureViaCanvas(decorView, bitmap)
+        }
+      }, copyHandler)
+    } catch (e: Exception) {
+      captureViaCanvas(decorView, bitmap)
+    }
+  }
+
+  private fun captureViaCanvas(view: View, bitmap: Bitmap) {
+    try {
+      val canvas = Canvas(bitmap)
+      view.draw(canvas)
+      applySensitiveMasks(bitmap, view)
+      onFrame(bitmap)
+    } catch (e: Exception) {
+      // Skip this frame
+    }
+  }
+
+  private fun applySensitiveMasks(bitmap: Bitmap, rootView: View) {
+    val tags = sensitiveViewManager.getViewTags()
+    if (tags.isEmpty()) return
+
+    val canvas = Canvas(bitmap)
+    val paint = android.graphics.Paint().apply {
+      color = Color.BLACK
+      style = android.graphics.Paint.Style.FILL
+    }
+
+    for (tag in tags) {
+      val sensitiveView = rootView.findViewWithTag<View>(tag) ?: continue
+      val location = IntArray(2)
+      sensitiveView.getLocationInWindow(location)
+      val rect = Rect(
+        location[0],
+        location[1],
+        location[0] + sensitiveView.width,
+        location[1] + sensitiveView.height
+      )
+      canvas.drawRect(rect, paint)
+    }
+  }
+}

package/android/src/main/java/com/sitepong/screenrecorder/ScreenRecorderModule.kt

@@ -0,0 +1,80 @@
+package com.sitepong.screenrecorder
+
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import expo.modules.kotlin.Promise
+
+class ScreenRecorderModule : Module() {
+  private var screenCapture: ScreenCapture? = null
+  private var encoder: H264Encoder? = null
+  private var uploader: ChunkUploader? = null
+  private val sensitiveViewManager = SensitiveViewManager()
+  private var recording = false
+
+  override fun definition() = ModuleDefinition {
+    Name("SitePongScreenRecorder")
+
+    Function("isRecording") {
+      recording
+    }
+
+    AsyncFunction("startRecording") { options: Map<String, Any?> ->
+      if (recording) return@AsyncFunction
+
+      val apiKey = options["apiKey"] as? String ?: ""
+      val endpoint = options["endpoint"] as? String ?: "https://ingest.sitepong.com"
+      val sessionId = options["sessionId"] as? String ?: ""
+      val fps = (options["fps"] as? Double)?.toInt() ?: 3
+      val quality = options["quality"] as? String ?: "standard"
+      val bufferDuration = (options["bufferDuration"] as? Double)?.toInt() ?: 20_000
+
+      val bitrate = when (quality) {
+        "low" -> 200_000
+        "high" -> 800_000
+        else -> 400_000
+      }
+
+      uploader = ChunkUploader(endpoint, apiKey, sessionId)
+
+      encoder = H264Encoder(bitrate, bufferDuration) { data, isKeyframe ->
+        uploader?.bufferNALUnit(data, isKeyframe)
+      }
+
+      val activity = appContext.currentActivity ?: return@AsyncFunction
+      screenCapture = ScreenCapture(activity, fps, sensitiveViewManager) { bitmap ->
+        encoder?.encode(bitmap)
+      }
+
+      encoder?.start(activity)
+      screenCapture?.start()
+      recording = true
+    }
+
+    AsyncFunction("stopRecording") {
+      stopInternal()
+    }
+
+    AsyncFunction("flushBuffer") {
+      if (!recording) return@AsyncFunction
+      encoder?.flushPendingFrames()
+      uploader?.flushBuffer()
+    }
+
+    Function("addSensitiveView") { viewTag: Int ->
+      sensitiveViewManager.addView(viewTag)
+    }
+
+    Function("removeSensitiveView") { viewTag: Int ->
+      sensitiveViewManager.removeView(viewTag)
+    }
+  }
+
+  private fun stopInternal() {
+    screenCapture?.stop()
+    encoder?.stop()
+    screenCapture = null
+    encoder = null
+    uploader = null
+    recording = false
+  }
+}

package/android/src/main/java/com/sitepong/screenrecorder/SensitiveViewManager.kt

@@ -0,0 +1,19 @@
+package com.sitepong.screenrecorder
+
+import java.util.concurrent.CopyOnWriteArraySet
+
+class SensitiveViewManager {
+  private val viewTags = CopyOnWriteArraySet<Int>()
+
+  fun addView(tag: Int) {
+    viewTags.add(tag)
+  }
+
+  fun removeView(tag: Int) {
+    viewTags.remove(tag)
+  }
+
+  fun getViewTags(): Set<Int> {
+    return viewTags.toSet()
+  }
+}