@repliqo/sdk-react-native 0.3.7 → 0.4.0

package/android/src/main/java/com/repliqo/screencapture/ScrollScanCapture.java

@@ -1,248 +0,0 @@
-package com.repliqo.screencapture;
-
-import android.app.Activity;
-import android.graphics.Bitmap;
-import android.graphics.Canvas;
-import android.util.Base64;
-import android.util.Log;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.ScrollView;
-
-import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.WritableArray;
-import com.facebook.react.bridge.WritableMap;
-
-import java.io.ByteArrayOutputStream;
-import java.lang.reflect.Field;
-import java.util.ArrayList;
-
-/**
- * Performs a fast programmatic scroll-scan of the main ScrollView to
- * capture the ENTIRE content as a series of viewport tiles.
- *
- * The scan is invisible to the user:
- *   1. Save current scroll position
- *   2. scrollTo(0, 0) — instant, no animation
- *   3. Capture viewport at Y=0
- *   4. scrollTo(0, viewportHeight) — instant
- *   5. Capture viewport at Y=viewportHeight
- *   6. ... repeat until end of content
- *   7. scrollTo(0, originalY) — restore position
- *
- * Total time: ~300-500ms for a typical screen. The user sees a brief
- * flicker at most (usually nothing because it happens within one frame).
- *
- * Must run on the UI thread.
- */
-public class ScrollScanCapture {
-    private static final String TAG = "RepliqoCapture";
-    private static final int TARGET_WIDTH = 390;
-    private static final int JPEG_QUALITY = 40;
-
-    /**
-     * Scan the ScrollView and return all viewport tiles.
-     *
-     * @return WritableArray of tile objects, or null on failure
-     */
-    public static WritableArray scan(Activity activity) {
-        if (activity == null || activity.isFinishing()) return null;
-
-        try {
-            View scrollView = findVerticalScrollView(activity);
-            if (scrollView == null) {
-                Log.d(TAG, "No ScrollView found for scan");
-                return null;
-            }
-
-            View contentView = getContentChild(scrollView);
-            if (contentView == null) return null;
-
-            int viewportWidth = scrollView.getWidth();
-            int viewportHeight = scrollView.getHeight();
-            int contentHeight = contentView.getHeight();
-
-            if (viewportWidth <= 0 || viewportHeight <= 0 || contentHeight <= 0) {
-                return null;
-            }
-
-            // If content fits in viewport, just capture once
-            if (contentHeight <= viewportHeight) {
-                WritableArray tiles = Arguments.createArray();
-                WritableMap tile = captureSingleTile(
-                    scrollView, 0, viewportWidth, viewportHeight, contentHeight
-                );
-                if (tile != null) tiles.pushMap(tile);
-                return tiles;
-            }
-
-            // Save original scroll position
-            int originalScrollY = scrollView.getScrollY();
-
-            WritableArray tiles = Arguments.createArray();
-
-            // Scan from top to bottom in viewport-sized steps
-            // Use 80% overlap to avoid gaps from scroll imprecision
-            int step = (int) (viewportHeight * 0.8);
-            int y = 0;
-
-            while (y < contentHeight) {
-                // Scroll to position — instant, no animation
-                scrollView.scrollTo(0, y);
-
-                // Force a layout pass so the views at this position render
-                scrollView.invalidate();
-                contentView.invalidate();
-
-                // Capture the viewport at this position
-                WritableMap tile = captureSingleTile(
-                    scrollView, y, viewportWidth, viewportHeight, contentHeight
-                );
-                if (tile != null) {
-                    tiles.pushMap(tile);
-                }
-
-                y += step;
-
-                // Last step: capture the very bottom
-                if (y >= contentHeight && y - step < contentHeight - viewportHeight) {
-                    y = contentHeight - viewportHeight;
-                    scrollView.scrollTo(0, y);
-                    scrollView.invalidate();
-                    contentView.invalidate();
-
-                    WritableMap lastTile = captureSingleTile(
-                        scrollView, y, viewportWidth, viewportHeight, contentHeight
-                    );
-                    if (lastTile != null) {
-                        tiles.pushMap(lastTile);
-                    }
-                    break;
-                }
-            }
-
-            // Restore original scroll position — instant
-            scrollView.scrollTo(0, originalScrollY);
-
-            Log.d(TAG, "Scroll scan complete: " + tiles.size() +
-                    " tiles, content=" + contentHeight + "px");
-
-            return tiles;
-
-        } catch (Exception e) {
-            Log.w(TAG, "ScrollScanCapture failed: " + e.getMessage());
-            return null;
-        }
-    }
-
-    private static WritableMap captureSingleTile(
-            View scrollView, int scrollY,
-            int viewportWidth, int viewportHeight, int contentHeight) {
-        try {
-            // Scale to target width
-            float scale = (float) TARGET_WIDTH / viewportWidth;
-            int outWidth = TARGET_WIDTH;
-            int outHeight = Math.round(viewportHeight * scale);
-
-            if (outWidth <= 0 || outHeight <= 0) return null;
-
-            Bitmap bitmap = Bitmap.createBitmap(outWidth, outHeight,
-                    Bitmap.Config.ARGB_8888);
-            Canvas canvas = new Canvas(bitmap);
-            canvas.scale(scale, scale);
-
-            // Translate canvas to account for scroll position within the view
-            canvas.translate(0, -scrollView.getScrollY());
-
-            // Draw the scrollview's content
-            View content = getContentChild(scrollView);
-            if (content != null) {
-                content.draw(canvas);
-            } else {
-                scrollView.draw(canvas);
-            }
-
-            // Compress to JPEG
-            ByteArrayOutputStream baos = new ByteArrayOutputStream();
-            bitmap.compress(Bitmap.CompressFormat.JPEG, JPEG_QUALITY, baos);
-            String base64 = Base64.encodeToString(baos.toByteArray(), Base64.NO_WRAP);
-            bitmap.recycle();
-
-            WritableMap tile = Arguments.createMap();
-            tile.putString("image", base64);
-            tile.putInt("width", outWidth);
-            tile.putInt("height", outHeight);
-            tile.putInt("scrollOffsetY", scrollY);
-            tile.putInt("viewportHeight", viewportHeight);
-            tile.putInt("contentHeight", contentHeight);
-            tile.putString("format", "jpeg");
-            return tile;
-
-        } catch (Exception e) {
-            Log.w(TAG, "Tile capture at Y=" + scrollY + " failed: " + e.getMessage());
-            return null;
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    private static View findVerticalScrollView(Activity activity) {
-        View decorView = activity.getWindow().getDecorView();
-        View found = findInTree(decorView);
-        if (found != null) return found;
-
-        try {
-            Class<?> wmgClass = Class.forName("android.view.WindowManagerGlobal");
-            Object wmg = wmgClass.getMethod("getInstance").invoke(null);
-            Field viewsField = wmgClass.getDeclaredField("mViews");
-            viewsField.setAccessible(true);
-            ArrayList<View> views = (ArrayList<View>) viewsField.get(wmg);
-            if (views != null) {
-                for (View root : views) {
-                    if (root == decorView) continue;
-                    found = findInTree(root);
-                    if (found != null) return found;
-                }
-            }
-        } catch (Exception e) { }
-
-        return null;
-    }
-
-    private static View findInTree(View view) {
-        if (view == null) return null;
-        if (isVerticalScroll(view) && view instanceof ViewGroup
-                && ((ViewGroup) view).getChildCount() > 0) {
-            return view;
-        }
-        if (view instanceof ViewGroup) {
-            ViewGroup group = (ViewGroup) view;
-            for (int i = 0; i < group.getChildCount(); i++) {
-                View found = findInTree(group.getChildAt(i));
-                if (found != null) return found;
-            }
-        }
-        return null;
-    }
-
-    private static boolean isVerticalScroll(View view) {
-        if (view instanceof ScrollView) return true;
-        Class<?> clazz = view.getClass();
-        while (clazz != null && clazz != View.class) {
-            String name = clazz.getName();
-            if (name.contains("Horizontal")) return false;
-            if (name.contains("NestedScrollView") ||
-                name.contains("ReactScrollView") ||
-                name.endsWith("ScrollView")) return true;
-            clazz = clazz.getSuperclass();
-        }
-        return false;
-    }
-
-    private static View getContentChild(View scrollView) {
-        if (scrollView instanceof ViewGroup) {
-            ViewGroup group = (ViewGroup) scrollView;
-            if (group.getChildCount() > 0) return group.getChildAt(0);
-        }
-        return null;
-    }
-}

package/src/snapshot/ScreenCaptureManager.ts

@@ -1,156 +0,0 @@
-import { captureFullContent } from './NativeScreenCapture';
-
-/** 24 hours in milliseconds. */
-const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
-
-/** Wait for screen to render before capturing. */
-const RENDER_DELAY_MS = 800;
-
-/** Max base64 size to upload (3MB base64 ≈ ~2.2MB binary). */
-const MAX_IMAGE_SIZE = 3 * 1024 * 1024;
-
-export type UploadFn = (
-  screenName: string,
-  image: string,
-  width: number,
-  height: number,
-  isFullContent: boolean,
-) => Promise<void>;
-
-/**
- * Manages full-content screen captures for heatmap backgrounds.
- *
- * - Captures the full ScrollView content on screen enter
- * - Local cache with 24h TTL to avoid redundant captures
- * - Cancels pending captures when navigating away (prevents cross-screen bugs)
- * - Async and non-blocking: never delays navigation or crashes the app
- */
-export class ScreenCaptureManager {
-  private cache = new Map<string, number>();
-  private pending = new Set<string>();
-  private pendingTimer: ReturnType<typeof setTimeout> | null = null;
-  private currentScreen: string | null = null;
-  private uploadFn: UploadFn;
-  private debug: boolean;
-
-  constructor(uploadFn: UploadFn, debug = false) {
-    this.uploadFn = uploadFn;
-    this.debug = debug;
-  }
-
-  /**
-   * Called when the user enters a screen. Schedules a full-content
-   * capture after a delay if no recent capture exists.
-   *
-   * Cancels any pending capture from a previous screen to prevent
-   * cross-screen data corruption (capturing screen B but labeling as A).
-   */
-  onScreenEnter(screenName: string): void {
-    // Cancel any pending capture from the previous screen
-    this.cancelPending();
-    this.currentScreen = screenName;
-
-    if (!this.shouldCapture(screenName)) return;
-
-    this.pending.add(screenName);
-
-    this.pendingTimer = setTimeout(() => {
-      this.pendingTimer = null;
-      // Verify the user is STILL on this screen before capturing
-      if (this.currentScreen !== screenName) {
-        this.pending.delete(screenName);
-        if (this.debug) {
-          console.log(
-            `[Repliqo] Screen capture skipped: navigated away from "${screenName}"`,
-          );
-        }
-        return;
-      }
-      this.captureAndUpload(screenName).catch(() => {});
-    }, RENDER_DELAY_MS);
-  }
-
-  private shouldCapture(screenName: string): boolean {
-    if (this.pending.has(screenName)) return false;
-
-    const lastCapture = this.cache.get(screenName);
-    if (lastCapture && Date.now() - lastCapture < CACHE_TTL_MS) {
-      return false;
-    }
-
-    return true;
-  }
-
-  private async captureAndUpload(screenName: string): Promise<void> {
-    try {
-      const result = await captureFullContent();
-      if (!result) {
-        if (this.debug) {
-          console.log(`[Repliqo] Screen capture returned null for "${screenName}"`);
-        }
-        return;
-      }
-
-      // Guard: check we're still on the same screen after the async capture
-      if (this.currentScreen !== screenName) {
-        if (this.debug) {
-          console.log(
-            `[Repliqo] Screen capture discarded: user left "${screenName}" during capture`,
-          );
-        }
-        return;
-      }
-
-      // Guard: reject oversized images to prevent OOM during upload
-      if (result.image.length > MAX_IMAGE_SIZE) {
-        if (this.debug) {
-          console.warn(
-            `[Repliqo] Screen capture too large (${Math.round(result.image.length / 1024)}KB), skipping "${screenName}"`,
-          );
-        }
-        return;
-      }
-
-      if (this.debug) {
-        console.log(
-          `[Repliqo] Screen captured: "${screenName}" ${result.width}x${result.height} ` +
-            `(full=${result.isFullContent}, ${Math.round(result.image.length / 1024)}KB)`,
-        );
-      }
-
-      await this.uploadFn(
-        screenName,
-        result.image,
-        result.width,
-        result.height,
-        result.isFullContent,
-      );
-
-      this.cache.set(screenName, Date.now());
-
-      if (this.debug) {
-        console.log(`[Repliqo] Screen capture uploaded: "${screenName}"`);
-      }
-    } catch (err) {
-      if (this.debug) {
-        console.warn(`[Repliqo] Screen capture failed for "${screenName}":`, err);
-      }
-    } finally {
-      this.pending.delete(screenName);
-    }
-  }
-
-  private cancelPending(): void {
-    if (this.pendingTimer !== null) {
-      clearTimeout(this.pendingTimer);
-      this.pendingTimer = null;
-    }
-  }
-
-  reset(): void {
-    this.cancelPending();
-    this.cache.clear();
-    this.pending.clear();
-    this.currentScreen = null;
-  }
-}