catalyst-core 0.1.0-canary.8 → 0.2.0-beta.1

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/TransitionManager.kt

@@ -0,0 +1,202 @@
+package io.yourname.androidproject
+
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.animation.ValueAnimator
+import android.app.Activity
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import android.view.View
+import android.view.ViewGroup
+import android.webkit.WebView
+import android.widget.FrameLayout
+import android.widget.ImageView
+import io.yourname.androidproject.utils.BridgeUtils
+
+/**
+ * Manages native page transitions using a snapshot-overlay pattern.
+ *
+ * Flow:
+ *   startTransition()  — captures a bitmap of the current WebView, places it as an
+ *                        ImageView overlay on top of the content, covering the skeleton
+ *                        rendered by the router while the new page loads.
+ *   commitTransition() — animates the overlay out (slide or fade) to reveal the new page.
+ *   cancelTransition() — removes the overlay immediately without animating.
+ *
+ * Safety timer: a Handler timer fires on the main thread after `timeout` ms if
+ *   commitTransition() was never called (JS error/hang). It force-fades the overlay
+ *   and fires ON_TRANSITION_TIMEOUT to JS so the hook can reset its state.
+ *
+ * Thread safety: all public methods must be called on the main thread.
+ */
+class TransitionManager(
+    private val activity: Activity,
+    private val webView: WebView
+) {
+    private val TAG = "TransitionManager"
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    private var overlayView: ImageView? = null
+    private var safetyRunnable: Runnable? = null
+    private var activeDuration: Int = 300
+    private var activeType: String = "slide"
+    private var activeDirection: String = "left"
+
+    // -------------------------------------------------------------------------
+    // Public API
+    // -------------------------------------------------------------------------
+
+    fun startTransition(type: String, direction: String, duration: Int, timeout: Int) {
+        // Cancel any orphaned transition first
+        cancelTransitionInternal(notify = false)
+
+        activeType = type
+        activeDirection = direction
+        activeDuration = duration
+
+        val snapshot = captureSnapshot() ?: run {
+            Log.w(TAG, "startTransition — snapshot failed, transition skipped")
+            return
+        }
+
+        val overlay = ImageView(activity).apply {
+            setImageBitmap(snapshot)
+            layoutParams = ViewGroup.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT
+            )
+            scaleType = ImageView.ScaleType.MATRIX
+        }
+
+        val root = activity.window.decorView as ViewGroup
+        root.addView(overlay)
+        overlayView = overlay
+
+        Log.d(TAG, "startTransition — overlay attached (type=$type direction=$direction duration=${duration}ms timeout=${timeout}ms)")
+
+        // Arm safety timer
+        val safety = Runnable {
+            Log.w(TAG, "startTransition — safety timeout fired, force-removing overlay")
+            cancelTransitionInternal(notify = false)
+            BridgeUtils.notifyWebSuccess(webView, BridgeUtils.WebEvents.ON_TRANSITION_TIMEOUT)
+        }
+        safetyRunnable = safety
+        mainHandler.postDelayed(safety, timeout.toLong())
+    }
+
+    fun commitTransition() {
+        val overlay = overlayView ?: run {
+            Log.w(TAG, "commitTransition — no active overlay, ignoring")
+            return
+        }
+
+        // Disarm safety timer — we're committing normally
+        disarmSafetyTimer()
+
+        when (activeType) {
+            "fade" -> animateFadeOut(overlay, activeDuration)
+            else -> animateSlideOut(overlay, activeDuration, activeDirection)
+        }
+    }
+
+    fun cancelTransition() {
+        cancelTransitionInternal(notify = true)
+    }
+
+    fun cleanup() {
+        cancelTransitionInternal(notify = false)
+    }
+
+    // -------------------------------------------------------------------------
+    // Private helpers
+    // -------------------------------------------------------------------------
+
+    private fun captureSnapshot(): Bitmap? {
+        return try {
+            val bmp = Bitmap.createBitmap(webView.width, webView.height, Bitmap.Config.ARGB_8888)
+            val canvas = Canvas(bmp)
+            webView.draw(canvas)
+            bmp
+        } catch (e: Exception) {
+            Log.e(TAG, "captureSnapshot failed", e)
+            null
+        }
+    }
+
+    private fun animateSlideOut(overlay: ImageView, duration: Int, direction: String) {
+        val root = activity.window.decorView as ViewGroup
+        val w = root.width.toFloat()
+        val h = root.height.toFloat()
+
+        val (endX, endY) = when (direction) {
+            "right" -> Pair(-w, 0f)
+            "up"    -> Pair(0f, h)
+            "down"  -> Pair(0f, -h)
+            else    -> Pair(w, 0f)   // "left" — overlay slides out to the right
+        }
+
+        ValueAnimator.ofFloat(0f, 1f).apply {
+            this.duration = duration.toLong()
+            addUpdateListener { anim ->
+                val fraction = anim.animatedFraction
+                overlay.translationX = endX * fraction
+                overlay.translationY = endY * fraction
+            }
+            addListener(object : AnimatorListenerAdapter() {
+                override fun onAnimationEnd(animation: Animator) {
+                    removeOverlay(overlay)
+                    BridgeUtils.notifyWebSuccess(webView, BridgeUtils.WebEvents.ON_TRANSITION_COMMITTED)
+                }
+            })
+            start()
+        }
+    }
+
+    private fun animateFadeOut(overlay: ImageView, duration: Int) {
+        ValueAnimator.ofFloat(1f, 0f).apply {
+            this.duration = duration.toLong()
+            addUpdateListener { anim ->
+                overlay.alpha = anim.animatedValue as Float
+            }
+            addListener(object : AnimatorListenerAdapter() {
+                override fun onAnimationEnd(animation: Animator) {
+                    removeOverlay(overlay)
+                    BridgeUtils.notifyWebSuccess(webView, BridgeUtils.WebEvents.ON_TRANSITION_COMMITTED)
+                }
+            })
+            start()
+        }
+    }
+
+    private fun cancelTransitionInternal(notify: Boolean) {
+        disarmSafetyTimer()
+
+        overlayView?.let { overlay ->
+            removeOverlay(overlay)
+            if (notify) {
+                BridgeUtils.notifyWebSuccess(webView, BridgeUtils.WebEvents.ON_TRANSITION_CANCELLED)
+            }
+        }
+    }
+
+    private fun removeOverlay(overlay: ImageView) {
+        try {
+            val root = activity.window.decorView as ViewGroup
+            root.removeView(overlay)
+        } catch (e: Exception) {
+            Log.w(TAG, "removeOverlay — view already detached: ${e.message}")
+        }
+        if (overlayView === overlay) {
+            overlayView = null
+        }
+        overlay.setImageBitmap(null)
+    }
+
+    private fun disarmSafetyTimer() {
+        safetyRunnable?.let { mainHandler.removeCallbacks(it) }
+        safetyRunnable = null
+    }
+}

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/WebCacheManager.kt

@@ -330,25 +330,27 @@ class WebCacheManager(private val context: Context, private val properties: java
                 val eTag = connection.getHeaderField("ETag")
                 val lastModified = connection.getHeaderField("Last-Modified")
 
+                // Capture all response headers for replay on cache hits
+                val savedHeaders = mutableMapOf<String, String>()
+                var i = 0
+                while (true) {
+                    val key = connection.getHeaderFieldKey(i) ?: break
+                    val value = connection.getHeaderField(i)
+                    if (key.isNotEmpty()) savedHeaders[key] = value
+                    i++
+                }
+
                 val responseBytes = connection.inputStream.use { it.readBytes() }
                 if (!isValidResponse(mimeType, responseBytes)) {
                     return@withContext null
                 }
 
                 // Create response for immediate use
-                val response = WebResourceResponse(
-                        mimeType,
-                        encoding,
-                        ByteArrayInputStream(responseBytes)
-                    )
+                val response = WebResourceResponse(mimeType, encoding, 200, "OK", savedHeaders, ByteArrayInputStream(responseBytes))
 
                 // Cache the response
                 val cacheEntry = CacheEntry(
-                    response = WebResourceResponse(
-                        mimeType,
-                        encoding,
-                        ByteArrayInputStream(responseBytes.copyOf())
-                    ),
+                    response = WebResourceResponse(mimeType, encoding, 200, "OK", savedHeaders, ByteArrayInputStream(responseBytes.copyOf())),
                     eTag = eTag,
                     lastModified = lastModified
                 )
@@ -363,7 +365,8 @@ class WebCacheManager(private val context: Context, private val properties: java
                             mimeType = mimeType,
                             encoding = encoding,
                             eTag = eTag,
-                            lastModified = lastModified
+                            lastModified = lastModified,
+                            responseHeaders = savedHeaders
                         ))
                         if (BuildConfig.DEBUG) {
                             Log.d(TAG, "✅ Successfully cached response for: $url")
@@ -391,25 +394,29 @@ class WebCacheManager(private val context: Context, private val properties: java
         val mimeType: String,
         val encoding: String,
         val eTag: String? = null,
-        val lastModified: String? = null
+        val lastModified: String? = null,
+        val responseHeaders: Map<String, String> = emptyMap()
     ) : Serializable
 
     private fun createResponseFromCache(cacheFile: File, metadata: CacheMetadata): WebResourceResponse {
         return WebResourceResponse(
             metadata.mimeType,
             metadata.encoding,
+            200,
+            "OK",
+            metadata.responseHeaders.ifEmpty { null },
             BufferedInputStream(FileInputStream(cacheFile), BUFFER_SIZE)
         )
     }
 
     private fun generateCacheKey(url: String): String {
         try {
-            val md = MessageDigest.getInstance("MD5")
+            val md = MessageDigest.getInstance("SHA-256")
             val digest = md.digest(url.toByteArray())
             return digest.joinToString("") { "%02x".format(it) }
         } catch (e: Exception) {
             Log.e(TAG, "Error generating cache key: ${e.message}")
-            // Fallback to a simple hash code if MD5 fails
+            // Fallback to a simple hash code if SHA-256 fails
             return url.hashCode().toString()
         }
     }
@@ -459,4 +466,4 @@ class WebCacheManager(private val context: Context, private val properties: java
             )
         }
     }
-}
+}

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/camera/BarcodeDetector.kt

@@ -0,0 +1,123 @@
+package io.yourname.androidproject.camera
+
+import android.util.Log
+import androidx.camera.core.ImageAnalysis
+import androidx.camera.core.ImageProxy
+import com.google.mlkit.vision.barcode.BarcodeScanner
+import com.google.mlkit.vision.barcode.BarcodeScannerOptions
+import com.google.mlkit.vision.barcode.BarcodeScanning
+import com.google.mlkit.vision.barcode.ZoomSuggestionOptions
+import com.google.mlkit.vision.barcode.common.Barcode
+import com.google.mlkit.vision.common.InputImage
+import java.util.concurrent.ExecutorService
+
+/**
+ * Wraps ML Kit barcode scanning.
+ * Builds the scanner with format filter and optional auto-zoom.
+ * Fires [onDetected] for each barcode found in a frame.
+ */
+class BarcodeDetector(
+    private val zoomController: ZoomController,
+    private val onDetected: (barcode: Barcode, imageWidth: Int, imageHeight: Int) -> Unit
+) {
+
+    private val TAG = "BarcodeDetector"
+
+    private var scanner: BarcodeScanner? = null
+
+    /** When true, frames are still analyzed (no flicker) but results are not forwarded. */
+    @Volatile var suppressResults = false
+
+    /** scan: "qr" | "barcode" | "all" */
+    fun buildImageAnalysis(
+        executor: ExecutorService,
+        resolutionSelector: androidx.camera.core.resolutionselector.ResolutionSelector,
+        autoZoomEnabled: Boolean,
+        scanFormat: String
+    ): ImageAnalysis {
+        val formats = resolveFormats(scanFormat)
+        val optionsBuilder = BarcodeScannerOptions.Builder()
+            .setBarcodeFormats(formats.first(), *formats.drop(1).toIntArray())
+
+        if (autoZoomEnabled) {
+            Log.d(TAG, "Auto-zoom enabled, wiring ZoomSuggestionOptions")
+            optionsBuilder.setZoomSuggestionOptions(
+                ZoomSuggestionOptions.Builder { suggestedRatio ->
+                    zoomController.onAutoZoomSuggestion(suggestedRatio)
+                }
+                .setMaxSupportedZoomRatio(zoomController.currentMaxZoomRatio())
+                .build()
+            )
+        }
+
+        scanner?.close()
+        val newScanner = BarcodeScanning.getClient(optionsBuilder.build())
+        scanner = newScanner
+
+        return ImageAnalysis.Builder()
+            .setResolutionSelector(resolutionSelector)
+            .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+            .build()
+            .also { analysis ->
+                // Capture newScanner (not the field) so this analyzer always uses
+                // the scanner instance that was live when buildImageAnalysis() ran.
+                analysis.setAnalyzer(executor) { imageProxy ->
+                    processFrame(imageProxy, newScanner)
+                }
+            }
+    }
+
+    fun close() {
+        scanner?.close()
+        scanner = null
+    }
+
+    private fun processFrame(imageProxy: ImageProxy, activeScanner: BarcodeScanner) {
+        val mediaImage = imageProxy.image
+        if (mediaImage == null) {
+            imageProxy.close()
+            return
+        }
+        val rotDeg = imageProxy.imageInfo.rotationDegrees
+        val image = InputImage.fromMediaImage(mediaImage, rotDeg)
+        // Swap w/h for 90°/270° — ML Kit boxes are in post-rotation space
+        val imgW = if (rotDeg == 90 || rotDeg == 270) imageProxy.height else imageProxy.width
+        val imgH = if (rotDeg == 90 || rotDeg == 270) imageProxy.width else imageProxy.height
+
+        activeScanner.process(image)
+            .addOnSuccessListener { barcodes ->
+                if (!suppressResults) {
+                    barcodes.forEach { onDetected(it, imgW, imgH) }
+                }
+            }
+            .addOnFailureListener { e -> Log.w(TAG, "Barcode processing failed", e) }
+            .addOnCompleteListener { imageProxy.close() }
+    }
+
+    private fun resolveFormats(scan: String): List<Int> = when (scan) {
+        "qr"      -> listOf(Barcode.FORMAT_QR_CODE)
+        "barcode" -> listOf(
+            Barcode.FORMAT_EAN_13, Barcode.FORMAT_EAN_8,
+            Barcode.FORMAT_CODE_128, Barcode.FORMAT_CODE_39,
+            Barcode.FORMAT_UPC_A, Barcode.FORMAT_UPC_E,
+            Barcode.FORMAT_PDF417
+        )
+        else      -> listOf(Barcode.FORMAT_ALL_FORMATS)
+    }
+
+    companion object {
+        fun formatName(format: Int): String = when (format) {
+            Barcode.FORMAT_QR_CODE    -> "QR"
+            Barcode.FORMAT_EAN_13     -> "EAN_13"
+            Barcode.FORMAT_EAN_8      -> "EAN_8"
+            Barcode.FORMAT_CODE_128   -> "CODE_128"
+            Barcode.FORMAT_CODE_39    -> "CODE_39"
+            Barcode.FORMAT_DATA_MATRIX -> "DATA_MATRIX"
+            Barcode.FORMAT_PDF417     -> "PDF417"
+            Barcode.FORMAT_AZTEC      -> "AZTEC"
+            Barcode.FORMAT_UPC_A      -> "UPC_A"
+            Barcode.FORMAT_UPC_E      -> "UPC_E"
+            else                      -> "UNKNOWN"
+        }
+    }
+}

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/camera/CameraSessionManager.kt

@@ -0,0 +1,244 @@
+package io.yourname.androidproject.camera
+
+import android.Manifest
+import android.content.pm.PackageManager
+import android.util.Log
+import android.util.Size
+import android.view.View
+import android.hardware.camera2.CaptureRequest
+import android.util.Range
+import androidx.camera.camera2.interop.Camera2Interop
+import androidx.camera.core.Camera
+import androidx.camera.core.CameraSelector
+import androidx.camera.core.ImageAnalysis
+import androidx.camera.core.Preview
+import androidx.camera.core.resolutionselector.ResolutionFilter
+import androidx.camera.core.resolutionselector.ResolutionSelector
+import androidx.camera.core.resolutionselector.ResolutionStrategy
+import androidx.camera.lifecycle.ProcessCameraProvider
+import androidx.camera.view.PreviewView
+import androidx.core.content.ContextCompat
+import androidx.lifecycle.LifecycleOwner
+import io.yourname.androidproject.MainActivity
+import io.yourname.androidproject.utils.BridgeUtils
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+
+/**
+ * Owns the CameraX session lifecycle: bind, stop, flip, setFps.
+ */
+class CameraSessionManager(
+    private val activity: MainActivity,
+    private val previewView: PreviewView,
+    private val stateMachine: VideoStreamStateMachine,
+    private val zoomController: ZoomController,
+    private val torchController: TorchController,
+    private val barcodeDetector: BarcodeDetector,
+    private val onReady: () -> Unit,
+    private val onStopped: () -> Unit,
+    private val onError: (message: String) -> Unit
+) {
+
+    companion object {
+        private const val TAG = "CameraSessionManager"
+        const val PERMISSION_REQUEST_CODE = 1001
+    }
+
+    private var cameraProvider: ProcessCameraProvider? = null
+    private var camera: Camera? = null
+    val cameraExecutor: ExecutorService = Executors.newSingleThreadExecutor()
+
+    private var previewUseCase: Preview? = null
+    private var imageAnalysisUseCase: ImageAnalysis? = null
+
+    // Session params — stored so flip/setFps can rebind with same settings
+    private var currentFacing: String = "back"
+    private var currentFpsMin: Int? = null
+    private var currentFpsMax: Int? = null
+    private var currentScanFormat: String = "all"
+    private var currentAutoZoom: Boolean = false
+    private var currentInitialZoom: Float = 1.0f
+
+    // ---- Public API ----
+
+    fun start(
+        facing: String,
+        autoZoom: Boolean,
+        initialZoomPct: Float,
+        scanFormat: String,
+        fpsMin: Int?,
+        fpsMax: Int?
+    ) {
+        if (cameraProvider != null) {
+            Log.w(TAG, "start() called while already streaming — ignoring")
+            return
+        }
+        currentFacing = facing
+        currentAutoZoom = autoZoom
+        currentInitialZoom = initialZoomPct
+        currentScanFormat = scanFormat
+        currentFpsMin = fpsMin
+        currentFpsMax = fpsMax
+
+        if (ContextCompat.checkSelfPermission(activity, Manifest.permission.CAMERA)
+            == PackageManager.PERMISSION_GRANTED
+        ) {
+            bindCamera()
+        } else {
+            activity.requestPermissions(arrayOf(Manifest.permission.CAMERA), PERMISSION_REQUEST_CODE)
+        }
+    }
+
+    fun stop() {
+        cameraProvider?.unbindAll()
+        cameraProvider = null
+        camera = null
+        previewUseCase = null
+        imageAnalysisUseCase = null
+        barcodeDetector.close()
+        zoomController.detachCamera()
+        torchController.detachCamera()
+        activity.runOnUiThread {
+            previewView.visibility = View.INVISIBLE
+            stateMachine.transition(VideoStreamState.IDLE)
+            onStopped()
+        }
+        Log.d(TAG, "Camera stopped")
+    }
+
+    fun flip() {
+        val newFacing = if (currentFacing == "back") "front" else "back"
+        Log.d(TAG, "flip() — $currentFacing → $newFacing")
+        currentFacing = newFacing
+        cleanupForRebind()
+        bindCamera()
+    }
+
+    fun setFps(min: Int?, max: Int?) {
+        if (min != null && max != null && min > max) {
+            Log.w(TAG, "setFps() — invalid range min=$min > max=$max, ignoring")
+            return
+        }
+        Log.d(TAG, "setFps($min, $max) — restarting session")
+        currentFpsMin = min
+        currentFpsMax = max
+        cleanupForRebind()
+        bindCamera()
+    }
+
+    private fun cleanupForRebind() {
+        barcodeDetector.close()
+        cameraProvider?.unbindAll()
+        camera = null
+        previewUseCase = null
+        imageAnalysisUseCase = null
+        zoomController.detachCamera()
+        torchController.detachCamera()
+    }
+
+    fun onPermissionResult(granted: Boolean) {
+        if (granted) {
+            bindCamera()
+        } else {
+            stateMachine.transition(VideoStreamState.IDLE)
+            onError("Camera permission denied")
+        }
+    }
+
+    fun cleanup() {
+        stop()
+        cameraExecutor.shutdown()
+    }
+
+    // ---- Internal ----
+
+    private fun bindCamera() {
+        val future = ProcessCameraProvider.getInstance(activity)
+        future.addListener({
+            try {
+                cameraProvider = future.get()
+
+                val previewBuilder = Preview.Builder()
+                    .setResolutionSelector(
+                        ResolutionSelector.Builder()
+                            .setResolutionFilter { supportedSizes, _ ->
+                                supportedSizes.sortedByDescending { it.width * it.height }
+                            }
+                            .build()
+                    )
+                val fpsMin = currentFpsMin
+                val fpsMax = currentFpsMax
+                if (fpsMin != null && fpsMax != null) {
+                    if (fpsMin <= fpsMax) {
+                        Camera2Interop.Extender(previewBuilder)
+                            .setCaptureRequestOption(
+                                CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE,
+                                Range(fpsMin, fpsMax)
+                            )
+                    } else {
+                        Log.w(TAG, "bindCamera — invalid FPS range min=$fpsMin > max=$fpsMax, skipping FPS override")
+                    }
+                }
+                previewUseCase = previewBuilder.build().also {
+                    it.setSurfaceProvider { request ->
+                        Log.d(TAG, "Preview resolution negotiated: ${request.resolution.width}x${request.resolution.height}")
+                        previewView.surfaceProvider.onSurfaceRequested(request)
+                    }
+                }
+
+                val resolutionSelector = ResolutionSelector.Builder()
+                    .setResolutionStrategy(
+                        ResolutionStrategy(
+                            Size(1920, 1080),
+                            ResolutionStrategy.FALLBACK_RULE_CLOSEST_HIGHER_THEN_LOWER
+                        )
+                    )
+                    .build()
+
+                imageAnalysisUseCase = barcodeDetector.buildImageAnalysis(
+                    executor = cameraExecutor,
+                    resolutionSelector = resolutionSelector,
+                    autoZoomEnabled = currentAutoZoom,
+                    scanFormat = currentScanFormat
+                )
+
+                cameraProvider?.unbindAll()
+                val boundCamera = cameraProvider?.bindToLifecycle(
+                    activity as LifecycleOwner,
+                    cameraSelector(currentFacing),
+                    previewUseCase!!,
+                    imageAnalysisUseCase!!
+                )
+                if (boundCamera == null) {
+                    Log.e(TAG, "bindToLifecycle returned null — aborting camera start")
+                    stateMachine.transition(VideoStreamState.IDLE)
+                    onError("Failed to bind camera to lifecycle")
+                    return@addListener
+                }
+                camera = boundCamera
+                zoomController.attachCamera(boundCamera)
+                torchController.attachCamera(boundCamera, currentFacing)
+
+                zoomController.applyZoomMultiplier(currentInitialZoom)
+                torchController.notifyReset()
+
+                stateMachine.transition(VideoStreamState.STREAMING)
+
+                activity.runOnUiThread {
+                    previewView.visibility = View.VISIBLE
+                    onReady()
+                }
+                Log.d(TAG, "Camera bound — facing=$currentFacing autoZoom=$currentAutoZoom")
+
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to bind camera", e)
+                stateMachine.transition(VideoStreamState.IDLE)
+                onError("Failed to start camera: ${e.message}")
+            }
+        }, ContextCompat.getMainExecutor(activity))
+    }
+
+    private fun cameraSelector(facing: String) =
+        if (facing == "front") CameraSelector.DEFAULT_FRONT_CAMERA
+        else CameraSelector.DEFAULT_BACK_CAMERA
+}